@varlet/release 1.0.5-alpha.1773908865255 → 1.1.0

package/dist/src-BWrnR5U-.js

@@ -0,0 +1,432 @@
+import { createWriteStream, existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { styleText } from "node:util";
+import { cancel, confirm, isCancel, select, spinner } from "@clack/prompts";
+import { logger } from "rslog";
+import semver from "semver";
+import { x } from "tinyexec";
+import conventionalChangelog from "conventional-changelog";
+//#region src/commitLint.ts
+const COMMIT_HEADER_RE = /^(revert|fix|feat|docs|perf|test|types|style|build|chore|release|refactor|merge|wip)(?:\(([^)]+)\))?(!)?:\s(.+)$/;
+const COMMIT_MESSAGE_RE = new RegExp(COMMIT_HEADER_RE.source.replace(/\$$/, "") + "(?:\\n[\\s\\S]+)?$");
+const ERROR_MESSAGE = "Commit message invalid.";
+const WARNING_MESSAGE = `\
+The rules for commit messages are as follows
+
+Example:
+
+feat: add a new feature
+feat(ui/button): add a new feature in the ui/button scope
+
+fix: fix a bug
+fix(ui/button): fix a bug in the ui/button scope
+
+docs: fix an error in the documentation
+docs(ui/button): fix a documentation error in the ui/button scope
+
+Allowed types:
+- fix
+- feat
+- docs
+- perf
+- test
+- types
+- style
+- build
+- chore
+- release
+- refactor
+- revert
+- merge
+- wip
+
+Commit message reference: https://docs.google.com/document/d/1QrDFcIiPjSLDn3EL15IJygNPiHORgU1_OOAqWjiDU5Y
+参考阮一峰Commit message编写指南: https://www.ruanyifeng.com/blog/2016/01/commit_message_change_log.html`;
+function isVersionCommitMessage(message) {
+	return Boolean(message.startsWith("v") && semver.valid(message.slice(1)));
+}
+function getCommitMessage(commitMessagePath) {
+	return readFileSync(commitMessagePath, "utf-8").trim();
+}
+function commitLint(options) {
+	const { commitMessagePath, commitMessageRe = COMMIT_MESSAGE_RE, errorMessage = ERROR_MESSAGE, warningMessage = WARNING_MESSAGE } = options;
+	if (!commitMessagePath) {
+		logger.error("commitMessagePath is required");
+		process.exit(1);
+	}
+	const commitMessage = getCommitMessage(commitMessagePath);
+	const isValidCommitMessage = new RegExp(commitMessageRe).test(commitMessage);
+	if (!isVersionCommitMessage(commitMessage) && !isValidCommitMessage) {
+		logger.error(errorMessage);
+		logger.warn(warningMessage);
+		process.exit(1);
+	}
+}
+//#endregion
+//#region src/changelog.ts
+const COMMIT_TYPE_MAP = {
+	feat: "Features",
+	fix: "Bug Fixes",
+	perf: "Performance Improvements",
+	revert: "Reverts",
+	refactor: "Code Refactoring",
+	docs: "Documentation",
+	style: "Styles",
+	test: "Tests",
+	build: "Build System",
+	ci: "Continuous Integration"
+};
+const ALWAYS_SHOW_TYPES = new Set([
+	"feat",
+	"fix",
+	"perf",
+	"revert",
+	"refactor"
+]);
+const BREAKING_CHANGE_RE = /BREAKING CHANGES?:\s*([\s\S]+)/;
+const MAIN_TEMPLATE = `{{> header}}
+
+{{> footer}}
+{{#each commitGroups}}
+
+{{#if title}}
+### {{title}}
+
+{{/if}}
+{{#each commits}}
+{{> commit root=@root}}
+{{/each}}
+
+{{/each}}
+`;
+function linkify(text, context, issues) {
+	let result = text;
+	const repoUrl = context.repository ? `${context.host}/${context.owner}/${context.repository}` : context.repoUrl;
+	if (repoUrl) {
+		const issueBaseUrl = `${repoUrl}/issues/`;
+		result = result.replace(/#([0-9]+)/g, (_, issue) => {
+			issues.push(issue);
+			return `[#${issue}](${issueBaseUrl}${issue})`;
+		});
+	}
+	if (context.host) result = result.replace(/\B@([a-z0-9](?:-?[a-z0-9/]){0,38})/g, (_, username) => username.includes("/") ? `@${username}` : `[@${username}](${context.host}/${username})`);
+	return result;
+}
+function extractBreakingText(commit) {
+	const body = typeof commit.body === "string" ? commit.body : "";
+	const footer = typeof commit.footer === "string" ? commit.footer : "";
+	const match = BREAKING_CHANGE_RE.exec(`${footer}\n${body}`);
+	if (match?.[1]) return match[1].trim();
+	if (typeof commit.subject === "string" && commit.subject) return commit.subject;
+	if (typeof commit.header === "string" && commit.header) return commit.header;
+	return "";
+}
+function tryParseHeader(commit) {
+	if (typeof commit.header !== "string") return null;
+	const match = COMMIT_HEADER_RE.exec(commit.header.trim());
+	if (!match) return null;
+	return {
+		type: match[1],
+		scope: match[2] || void 0,
+		subject: match[4] || void 0,
+		isBreaking: Boolean(match[3])
+	};
+}
+function processBreakingChanges(commit, context, issues) {
+	let discard = true;
+	commit.notes.forEach((note) => {
+		note.title = "BREAKING CHANGES";
+		discard = false;
+	});
+	const hadBreakingNotes = commit.notes.length > 0;
+	const addBreakingNote = () => {
+		if (!hadBreakingNotes) {
+			const text = linkify(extractBreakingText(commit), context, issues);
+			commit.notes.push({
+				title: "BREAKING CHANGES",
+				text
+			});
+		}
+		discard = false;
+	};
+	const parsed = tryParseHeader(commit);
+	if (parsed) {
+		if (!commit.type) commit.type = parsed.type;
+		if (!commit.scope && parsed.scope) commit.scope = parsed.scope;
+		if (!commit.subject && parsed.subject) commit.subject = parsed.subject;
+		if (parsed.isBreaking) addBreakingNote();
+	}
+	if (typeof commit.type === "string" && commit.type.endsWith("!")) {
+		commit.type = commit.type.slice(0, -1);
+		addBreakingNote();
+	}
+	return discard;
+}
+function mapCommitType(commit, discard) {
+	if (commit.revert) {
+		commit.type = "Reverts";
+		return true;
+	}
+	const mapped = COMMIT_TYPE_MAP[commit.type];
+	if (mapped) {
+		if (ALWAYS_SHOW_TYPES.has(commit.type) || !discard) {
+			commit.type = mapped;
+			return true;
+		}
+	}
+	return !discard;
+}
+function createDefaultWriterOpts() {
+	return {
+		mainTemplate: MAIN_TEMPLATE,
+		transform(commit, context) {
+			const issues = [];
+			if (!mapCommitType(commit, processBreakingChanges(commit, context, issues))) return false;
+			if (commit.scope === "*") commit.scope = "";
+			if (typeof commit.hash === "string") commit.shortHash = commit.hash.substring(0, 7);
+			if (typeof commit.subject === "string") commit.subject = linkify(commit.subject, context, issues);
+			commit.references = commit.references.filter((ref) => !issues.includes(ref.issue));
+			return commit;
+		}
+	};
+}
+function changelog({ releaseCount = 0, file = "CHANGELOG.md", preset = "angular", writerOpts = createDefaultWriterOpts() } = {}) {
+	const s = spinner();
+	s.start("Generating changelog");
+	return new Promise((resolve$1) => {
+		conventionalChangelog({
+			preset,
+			releaseCount
+		}, void 0, void 0, void 0, writerOpts).pipe(createWriteStream(resolve(process.cwd(), file))).on("close", () => {
+			s.stop("Changelog generated successfully!");
+			resolve$1();
+		});
+	});
+}
+//#endregion
+//#region src/utils.ts
+function readJSONSync(path) {
+	const content = readFileSync(path, "utf-8").replace(/^\uFEFF/, "");
+	try {
+		return JSON.parse(content);
+	} catch (err) {
+		err.message = `${path}: ${err.message}`;
+		throw err;
+	}
+}
+//#endregion
+//#region src/release.ts
+const cwd = () => process.cwd();
+const releaseTypes = [
+	"patch",
+	"minor",
+	"major",
+	"prepatch",
+	"preminor",
+	"premajor"
+];
+const BACK_HINT = "Back to previous step";
+async function isWorktreeEmpty() {
+	return !(await x("git", ["status", "--porcelain"])).stdout;
+}
+async function isSameVersion(version) {
+	const s = spinner();
+	s.start("Check remote version...");
+	const packageJsones = getPackageJsons();
+	const packageJson = packageJsones.find((packageJson) => !packageJson.config.private) || packageJsones[0];
+	if (packageJson) {
+		const { config } = packageJson;
+		try {
+			await x("npm", [
+				"view",
+				`${config.name}@${version ?? config.version}`,
+				"version"
+			], { throwOnError: true });
+			s.cancel();
+			logger.warn(`The npm package has a same remote version ${version ?? config.version}.`);
+			return true;
+		} catch {
+			s.stop();
+			return false;
+		}
+	}
+}
+async function publish({ preRelease, checkRemoteVersion, npmTag }) {
+	const s = spinner();
+	s.start("Publishing all packages");
+	const args = [
+		"-r",
+		"publish",
+		"--no-git-checks",
+		"--access",
+		"public"
+	];
+	if (checkRemoteVersion && await isSameVersion()) {
+		logger.error("publishing automatically skipped.");
+		return;
+	}
+	if (preRelease) args.push("--tag", "alpha");
+	else if (npmTag) args.push("--tag", npmTag);
+	try {
+		const ret = await x("pnpm", args, { throwOnError: true });
+		s.stop("Publish all packages successfully");
+		ret.stdout && logger.log(ret.stdout);
+	} catch (error) {
+		s.cancel("Publish all packages failed");
+		throw error?.output?.stderr ?? error;
+	}
+}
+async function pushGit(version, remote = "origin", skipGitTag = false) {
+	const s = spinner();
+	s.start("Pushing to remote git repository");
+	await x("git", ["add", "."], { throwOnError: true });
+	await x("git", [
+		"commit",
+		"-m",
+		`v${version}`
+	], { throwOnError: true });
+	if (!skipGitTag) {
+		await x("git", ["tag", `v${version}`], { throwOnError: true });
+		await x("git", [
+			"push",
+			remote,
+			`v${version}`
+		], { throwOnError: true });
+	}
+	const ret = await x("git", ["push"], { throwOnError: true });
+	s.stop("Push remote repository successfully");
+	ret.stdout && logger.log(ret.stdout);
+}
+function getPackageJsons() {
+	const packageJsons = [resolve(cwd(), "package.json")];
+	const packagesDir = resolve(cwd(), "packages");
+	if (existsSync(packagesDir)) for (const name of readdirSync(packagesDir)) {
+		const pkgPath = resolve(packagesDir, name, "package.json");
+		if (existsSync(pkgPath)) packageJsons.push(pkgPath);
+	}
+	return packageJsons.map((path) => {
+		return {
+			filePath: path,
+			config: readJSONSync(path)
+		};
+	});
+}
+function updateVersion(version) {
+	getPackageJsons().forEach(({ config, filePath }) => {
+		config.version = version;
+		writeFileSync(filePath, JSON.stringify(config, null, 2));
+	});
+}
+async function confirmRegistry() {
+	const registry = (await x("npm", [
+		"config",
+		"get",
+		"registry"
+	])).stdout;
+	const ret = await confirm({ message: `Current registry is: ${registry}` });
+	if (isCancel(ret)) {
+		cancel("Operation cancelled.");
+		process.exit(0);
+	}
+	return ret;
+}
+async function confirmVersion(currentVersion, expectVersion) {
+	const ret = await select({
+		message: "Version confirm",
+		options: [`All packages version ${currentVersion} -> ${expectVersion}`, BACK_HINT].map((value) => ({
+			label: value,
+			value
+		}))
+	});
+	if (isCancel(ret)) {
+		cancel("Operation cancelled.");
+		process.exit(0);
+	}
+	return ret;
+}
+async function confirmRefs(remote = "origin") {
+	const { stdout } = await x("git", ["remote", "-v"]);
+	const reg = new RegExp(`${remote}\t(.*) \\(push`);
+	const repo = stdout.match(reg)?.[1];
+	const { stdout: branch } = await x("git", ["branch", "--show-current"]);
+	const ret = await confirm({ message: `Current refs ${repo}:refs/for/${styleText("blue", branch)}` });
+	if (isCancel(ret)) {
+		cancel("Operation cancelled.");
+		process.exit(0);
+	}
+	return ret;
+}
+async function getReleaseType() {
+	const releaseType = await select({
+		message: "Please select release type",
+		options: releaseTypes.map((type) => ({
+			label: type,
+			value: type
+		}))
+	});
+	if (isCancel(releaseType)) {
+		cancel("Operation cancelled.");
+		process.exit(0);
+	}
+	return releaseType;
+}
+async function getReleaseVersion(currentVersion) {
+	let isPreRelease = false;
+	let expectVersion = "";
+	let confirmVersionRet = "";
+	do {
+		const type = await getReleaseType();
+		isPreRelease = type.startsWith("pre");
+		expectVersion = semver.inc(currentVersion, type, `alpha.${Date.now()}`);
+		expectVersion = isPreRelease ? expectVersion.slice(0, -2) : expectVersion;
+		confirmVersionRet = await confirmVersion(currentVersion, expectVersion);
+	} while (confirmVersionRet === BACK_HINT);
+	return {
+		isPreRelease,
+		expectVersion
+	};
+}
+async function release(options) {
+	try {
+		const currentVersion = readJSONSync(resolve(cwd(), "package.json")).version;
+		if (!currentVersion) {
+			logger.error("Your package is missing the version field");
+			return;
+		}
+		if (!await isWorktreeEmpty()) {
+			logger.error("Git worktree is not empty, please commit changed");
+			return;
+		}
+		if (!await confirmRefs(options.remote)) return;
+		if (!options.skipNpmPublish && !await confirmRegistry()) return;
+		const { isPreRelease, expectVersion } = await getReleaseVersion(currentVersion);
+		if (options.checkRemoteVersion && await isSameVersion(expectVersion)) {
+			logger.error("Please check remote version.");
+			return;
+		}
+		updateVersion(expectVersion);
+		if (options.task) await options.task(expectVersion, currentVersion);
+		if (!options.skipNpmPublish) await publish({
+			preRelease: isPreRelease,
+			npmTag: options.npmTag
+		});
+		if (!isPreRelease) {
+			if (!options.skipChangelog) await changelog();
+			await pushGit(expectVersion, options.remote, options.skipGitTag);
+		}
+		logger.success(`Release version ${expectVersion} successfully!`);
+		if (isPreRelease) {
+			try {
+				await x("git", ["restore", "**/package.json"], { throwOnError: true });
+			} catch {}
+			try {
+				await x("git", ["restore", "package.json"], { throwOnError: true });
+			} catch {}
+		}
+	} catch (error) {
+		logger.error(error);
+		process.exit(1);
+	}
+}
+//#endregion
+export { updateVersion as a, COMMIT_MESSAGE_RE as c, isVersionCommitMessage as d, release as i, commitLint as l, isSameVersion as n, changelog as o, publish as r, COMMIT_HEADER_RE as s, getPackageJsons as t, getCommitMessage as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@varlet/release",
-  "version": "1.0.5-alpha.1773908865255",
+  "version": "1.1.0",
   "description": "publish all packages, generate changelogs and check commit messages",
   "keywords": [
     "changelog",
@@ -42,33 +42,30 @@
     "package.json": "prettier --write"
   },
   "dependencies": {
-    "@clack/prompts": "^1.0.0",
+    "@clack/prompts": "^1.1.0",
     "commander": "^11.1.0",
     "conventional-changelog": "^5.1.0",
-    "fs-extra": "^11.3.3",
-    "rslog": "^2.0.0",
+    "rslog": "^2.0.1",
     "semver": "^7.5.4",
-    "tinyexec": "^1.0.2"
+    "tinyexec": "^1.0.4"
   },
   "devDependencies": {
     "@configurajs/eslint": "^0.1.2",
     "@configurajs/prettier": "^0.1.4",
     "@ianvs/prettier-plugin-sort-imports": "^4.7.1",
     "@types/conventional-changelog": "^3.1.5",
-    "@types/fs-extra": "^11.0.4",
     "@types/node": "^22.14.0",
     "@types/semver": "^7.5.5",
-    "@vitest/coverage-v8": "^4.0.18",
+    "@vitest/coverage-v8": "^4.1.0",
     "eslint": "^9.39.2",
     "lint-staged": "^16.2.7",
     "prettier": "^3.8.1",
     "prettier-plugin-packagejson": "^3.0.0",
     "prettier-plugin-tailwindcss": "^0.7.2",
-    "rimraf": "^6.1.2",
     "simple-git-hooks": "^2.13.1",
-    "tsdown": "^0.20.3",
+    "tsdown": "^0.21.4",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.18"
+    "vitest": "^4.1.0"
   },
   "engines": {
     "node": "^20.19.0 || >=22.12.0",
@@ -76,7 +73,6 @@
   },
   "scripts": {
     "build": "tsdown",
-    "clean": "rimraf node_modules dist",
     "commit-lint": "node dist/cli.js commit-lint",
     "dev": "tsdown --watch",
     "format": "eslint . --fix && prettier --write .",