@varlet/release 0.4.4 → 1.0.1

package/dist/index.js

@@ -1,301 +1,302 @@
-// src/release.ts
-import { resolve } from "path";
-import { confirm, select } from "@inquirer/prompts";
-import fse2 from "fs-extra";
-import { glob } from "glob";
-import { createSpinner as createSpinner2 } from "nanospinner";
+import { resolve } from "node:path";
+import { styleText } from "node:util";
+import { cancel, confirm, isCancel, select, spinner } from "@clack/prompts";
+import fse from "fs-extra";
 import { logger } from "rslog";
 import semver from "semver";
-import { x as exec } from "tinyexec";
-
-// src/changelog.ts
-import { resolve as resolvePath } from "path";
+import { x } from "tinyexec";
 import conventionalChangelog from "conventional-changelog";
-import fse from "fs-extra";
-import { createSpinner } from "nanospinner";
-var { createWriteStream } = fse;
-function changelog({
-  releaseCount = 0,
-  file = "CHANGELOG.md",
-  preset = "angular",
-  writerOpts = {
-    transform(commit, context) {
-      let discard = true;
-      const issues = [];
-      commit.notes.forEach((note) => {
-        note.title = "BREAKING CHANGES";
-        discard = false;
-      });
-      if (commit.type === "feat") {
-        commit.type = "Features";
-      } else if (commit.type === "fix") {
-        commit.type = "Bug Fixes";
-      } else if (commit.type === "perf") {
-        commit.type = "Performance Improvements";
-      } else if (commit.type === "revert" || commit.revert) {
-        commit.type = "Reverts";
-      } else if (commit.type === "refactor") {
-        commit.type = "Code Refactoring";
-      } else if (discard) {
-        return false;
-      } else if (commit.type === "docs") {
-        commit.type = "Documentation";
-      } else if (commit.type === "style") {
-        commit.type = "Styles";
-      } else if (commit.type === "test") {
-        commit.type = "Tests";
-      } else if (commit.type === "build") {
-        commit.type = "Build System";
-      } else if (commit.type === "ci") {
-        commit.type = "Continuous Integration";
-      }
-      if (commit.scope === "*") {
-        commit.scope = "";
-      }
-      if (typeof commit.hash === "string") {
-        commit.shortHash = commit.hash.substring(0, 7);
-      }
-      if (typeof commit.subject === "string") {
-        let url = context.repository ? `${context.host}/${context.owner}/${context.repository}` : context.repoUrl;
-        if (url) {
-          url = `${url}/issues/`;
-          commit.subject = commit.subject.replace(/#([0-9]+)/g, (_, issue) => {
-            issues.push(issue);
-            return `[#${issue}](${url}${issue})`;
-          });
-        }
-        if (context.host) {
-          commit.subject = commit.subject.replace(/\B@([a-z0-9](?:-?[a-z0-9/]){0,38})/g, (_, username) => {
-            if (username.includes("/")) {
-              return `@${username}`;
-            }
-            return `[@${username}](${context.host}/${username})`;
-          });
-        }
-      }
-      commit.references = commit.references.filter((reference) => {
-        if (issues.indexOf(reference.issue) === -1) {
-          return true;
-        }
-        return false;
-      });
-      return commit;
-    }
-  }
-} = {}) {
-  const s = createSpinner("Generating changelog").start();
-  return new Promise((resolve2) => {
-    conventionalChangelog(
-      {
-        preset,
-        releaseCount
-      },
-      void 0,
-      void 0,
-      void 0,
-      writerOpts
-    ).pipe(createWriteStream(resolvePath(process.cwd(), file))).on("close", () => {
-      s.success({ text: "Changelog generated success!" });
-      resolve2();
-    });
-  });
+
+//#region src/changelog.ts
+const { createWriteStream } = fse;
+function changelog({ releaseCount = 0, file = "CHANGELOG.md", preset = "angular", writerOpts = { transform(commit, context) {
+	let discard = true;
+	const issues = [];
+	commit.notes.forEach((note) => {
+		note.title = "BREAKING CHANGES";
+		discard = false;
+	});
+	const hasBreakingNotes = commit.notes.length > 0;
+	if (typeof commit.type === "string" && commit.type.endsWith("!")) {
+		commit.type = commit.type.slice(0, -1);
+		if (!hasBreakingNotes) commit.notes.push({
+			title: "BREAKING CHANGES",
+			text: ""
+		});
+		discard = false;
+	}
+	if (commit.type === "feat") commit.type = "Features";
+	else if (commit.type === "fix") commit.type = "Bug Fixes";
+	else if (commit.type === "perf") commit.type = "Performance Improvements";
+	else if (commit.type === "revert" || commit.revert) commit.type = "Reverts";
+	else if (commit.type === "refactor") commit.type = "Code Refactoring";
+	else if (discard) return false;
+	else if (commit.type === "docs") commit.type = "Documentation";
+	else if (commit.type === "style") commit.type = "Styles";
+	else if (commit.type === "test") commit.type = "Tests";
+	else if (commit.type === "build") commit.type = "Build System";
+	else if (commit.type === "ci") commit.type = "Continuous Integration";
+	if (commit.scope === "*") commit.scope = "";
+	if (typeof commit.hash === "string") commit.shortHash = commit.hash.substring(0, 7);
+	if (typeof commit.subject === "string") {
+		let url = context.repository ? `${context.host}/${context.owner}/${context.repository}` : context.repoUrl;
+		if (url) {
+			url = `${url}/issues/`;
+			commit.subject = commit.subject.replace(/#([0-9]+)/g, (_, issue) => {
+				issues.push(issue);
+				return `[#${issue}](${url}${issue})`;
+			});
+		}
+		if (context.host) commit.subject = commit.subject.replace(/\B@([a-z0-9](?:-?[a-z0-9/]){0,38})/g, (_, username) => {
+			if (username.includes("/")) return `@${username}`;
+			return `[@${username}](${context.host}/${username})`;
+		});
+	}
+	commit.references = commit.references.filter((reference) => {
+		if (issues.indexOf(reference.issue) === -1) return true;
+		return false;
+	});
+	return commit;
+} } } = {}) {
+	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();
+		});
+	});
 }
 
-// src/release.ts
-var cwd = process.cwd();
-var { writeFileSync, readJSONSync } = fse2;
-var releaseTypes = ["patch", "minor", "major", "prepatch", "preminor", "premajor"];
-var BACK_HINT = "Back to previous step";
+//#endregion
+//#region src/release.ts
+const cwd = process.cwd();
+const { writeFileSync, readJSONSync, existsSync, readdirSync } = fse;
+const releaseTypes = [
+	"patch",
+	"minor",
+	"major",
+	"prepatch",
+	"preminor",
+	"premajor"
+];
+const BACK_HINT = "Back to previous step";
 async function isWorktreeEmpty() {
-  const ret = await exec("git", ["status", "--porcelain"]);
-  return !ret.stdout;
+	return !(await x("git", ["status", "--porcelain"])).stdout;
 }
 async function isSameVersion(version) {
-  const s = createSpinner2("Check remote version...").start();
-  const packageJsones = getPackageJsons();
-  const packageJson = packageJsones.find((packageJson2) => !packageJson2.config.private) || packageJsones[0];
-  if (packageJson) {
-    const { config } = packageJson;
-    try {
-      await exec("npm", ["view", `${config.name}@${version ?? config.version}`, "version"], {
-        throwOnError: true
-      });
-      s.warn({
-        text: `The npm package has a same remote version ${version ?? config.version}.`
-      });
-      return true;
-    } catch {
-      s.success();
-      return false;
-    }
-  }
+	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 = createSpinner2("Publishing all packages").start();
-  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);
-  }
-  const ret = await exec("pnpm", args, { throwOnError: true });
-  s.success({ text: "Publish all packages successfully" });
-  ret.stdout && logger.log(ret.stdout);
+	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 = createSpinner2("Pushing to remote git repository").start();
-  await exec("git", ["add", "."], {
-    throwOnError: true
-  });
-  await exec("git", ["commit", "-m", `v${version}`], {
-    throwOnError: true
-  });
-  if (!skipGitTag) {
-    await exec("git", ["tag", `v${version}`], {
-      throwOnError: true
-    });
-    await exec("git", ["push", remote, `v${version}`], {
-      throwOnError: true
-    });
-  }
-  const ret = await exec("git", ["push"], {
-    throwOnError: true
-  });
-  s.success({ text: "Push remote repository successfully" });
-  ret.stdout && logger.log(ret.stdout);
+	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 getAllPackageJsons() {
+	const result = [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)) result.push(pkgPath);
+	}
+	return result;
 }
 function getPackageJsons() {
-  const packageJsons = ["package.json", ...glob.sync("packages/*/package.json")];
-  return packageJsons.map((path) => {
-    const filePath = resolve(cwd, path);
-    return {
-      config: readJSONSync(filePath),
-      filePath
-    };
-  });
+	return getAllPackageJsons().map((path) => {
+		return {
+			config: readJSONSync(path),
+			filePath: path
+		};
+	});
 }
 function updateVersion(version) {
-  const packageJsons = getPackageJsons();
-  packageJsons.forEach(({ config, filePath }) => {
-    config.version = version;
-    writeFileSync(filePath, JSON.stringify(config, null, 2));
-  });
+	getPackageJsons().forEach(({ config, filePath }) => {
+		config.version = version;
+		writeFileSync(filePath, JSON.stringify(config, null, 2));
+	});
 }
 async function confirmRegistry() {
-  const registry = (await exec("npm", ["config", "get", "registry"])).stdout;
-  const ret = await confirm({
-    message: `Current registry is: ${registry}`
-  });
-  return ret;
+	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",
-    choices: [`All packages version ${currentVersion} -> ${expectVersion}`, BACK_HINT].map((value) => ({
-      name: value,
-      value
-    }))
-  });
-  return ret;
+	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 exec("git", ["remote", "-v"]);
-  const reg = new RegExp(`${remote}	(.*) \\(push`);
-  const repo = stdout.match(reg)?.[1];
-  const { stdout: branch } = await exec("git", ["branch", "--show-current"]);
-  const ret = await confirm({
-    message: `Current refs ${repo}:refs/for/${branch}`
-  });
-  return ret;
+	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",
-    choices: releaseTypes.map((type) => ({ name: type, value: type }))
-  });
-  return releaseType;
+	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 };
+	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 exec("git", ["restore", "**/package.json"], {
-          throwOnError: true
-        });
-      } catch {
-      }
-      try {
-        await exec("git", ["restore", "package.json"], {
-          throwOnError: true
-        });
-      } catch {
-      }
-    }
-  } catch (error) {
-    logger.error(error.toString());
-    process.exit(1);
-  }
+	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);
+	}
 }
 
-// src/commitLint.ts
-import fse3 from "fs-extra";
-import { logger as logger2 } from "rslog";
-import semver2 from "semver";
-var { readFileSync } = fse3;
-var COMMIT_MESSAGE_RE = /^(revert|fix|feat|docs|perf|test|types|style|build|chore|release|refactor|merge|wip)(\(.+\))?!?: (.|\n)+/;
-var ERROR_MESSAGE = "Commit message invalid.";
-var WARNING_MESSAGE = `The rules for commit messages are as follows
+//#endregion
+//#region src/commitLint.ts
+const { readFileSync } = fse;
+const COMMIT_MESSAGE_RE = /^(revert|fix|feat|docs|perf|test|types|style|build|chore|release|refactor|merge|wip)(\(.+\))?!?: (.|\n)+/;
+const ERROR_MESSAGE = "Commit message invalid.";
+const WARNING_MESSAGE = `\
+The rules for commit messages are as follows
 
 Example:
 
@@ -325,40 +326,27 @@ Allowed types:
 - wip
 
 Commit message reference: https://docs.google.com/document/d/1QrDFcIiPjSLDn3EL15IJygNPiHORgU1_OOAqWjiDU5Y
-\u53C2\u8003\u962E\u4E00\u5CF0Commit message\u7F16\u5199\u6307\u5357: https://www.ruanyifeng.com/blog/2016/01/commit_message_change_log.html`;
+参考阮一峰Commit message编写指南: https://www.ruanyifeng.com/blog/2016/01/commit_message_change_log.html`;
 function isVersionCommitMessage(message) {
-  return message.startsWith("v") && semver2.valid(message.slice(1));
+	return Boolean(message.startsWith("v") && semver.valid(message.slice(1)));
 }
 function getCommitMessage(commitMessagePath) {
-  return readFileSync(commitMessagePath, "utf-8").trim();
+	return readFileSync(commitMessagePath, "utf-8").trim();
 }
 function commitLint(options) {
-  const {
-    commitMessagePath,
-    commitMessageRe = COMMIT_MESSAGE_RE,
-    errorMessage = ERROR_MESSAGE,
-    warningMessage = WARNING_MESSAGE
-  } = options;
-  if (!commitMessagePath) {
-    logger2.error("commitMessagePath is required");
-    process.exit(1);
-  }
-  const commitMessage = getCommitMessage(commitMessagePath);
-  const isValidCommitMessage = new RegExp(commitMessageRe).test(commitMessage);
-  if (!isVersionCommitMessage(commitMessage) && !isValidCommitMessage) {
-    logger2.error(errorMessage);
-    logger2.warn(warningMessage);
-    process.exit(1);
-  }
+	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);
+	}
 }
-export {
-  COMMIT_MESSAGE_RE,
-  changelog,
-  commitLint,
-  getCommitMessage,
-  isSameVersion,
-  isVersionCommitMessage,
-  publish,
-  release,
-  updateVersion
-};
+
+//#endregion
+export { COMMIT_MESSAGE_RE, changelog, commitLint, getAllPackageJsons, getCommitMessage, isSameVersion, isVersionCommitMessage, publish, release, updateVersion };