@cluerise/tools 3.0.1 → 4.0.0

package/dist/scripts/format-commit-message/main.js

@@ -1,9 +1,19 @@
-import FileSystem from "fs/promises";
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _config, _CommitLinter_instances, isValidEnumValue_fn, isValidType_fn, isValidScope_fn, _CommitLinter_static, parseSemanticCommitMessage_fn;
+import FileSystem from "node:fs/promises";
 import { z, ZodError } from "zod";
+import ChildProcess from "node:child_process";
+import loadCommitlintConfig from "@commitlint/load";
 import "eslint";
 import "glob";
 import "prettier";
-import loadCommitlintConfig from "@commitlint/load";
 const enginesSchema = z.object({
   node: z.string()
 });
@@ -21,40 +31,119 @@ z.object({
   repository: repositorySchema.optional()
 });
 const runMain = (main2) => {
-  main2(process.argv.slice(2)).then((exitCode) => {
+  Promise.resolve().then(() => main2(process.argv.slice(2))).then((exitCode) => {
     process.exit(exitCode);
   }).catch((error) => {
-    console.error(error);
+    console.error("Error:", error);
     process.exit(1);
   });
 };
-const capitalize = (value) => {
-  const [firstLetter] = value;
-  if (!firstLetter) {
-    return value;
+class StringUtils {
+  /**
+   * Capitalizes the first letter of a given string.
+   *
+   * @param value - The string to capitalize.
+   * @returns The string with the first letter capitalized.
+   */
+  static capitalize(value) {
+    const [firstLetter] = value;
+    if (!firstLetter) {
+      return value;
+    }
+    return `${firstLetter.toUpperCase()}${value.slice(1)}`;
   }
-  return `${firstLetter.toUpperCase()}${value.slice(1)}`;
-};
-const StringUtils = {
-  capitalize
-};
-z.union([z.literal("all"), z.literal("code")]);
-const stringifySemanticCommitMessagePrefix = ({ type, scope }) => `${type}${scope ? `(${scope})` : ""}`;
-const startsWithSemanticCommitMessagePrefix = (message, prefix) => message.startsWith(stringifySemanticCommitMessagePrefix(prefix));
-const createSemanticCommitMessage = (prefix, message) => {
-  const [subject, ...comments] = message.split("\n#");
-  let commitMessage = stringifySemanticCommitMessagePrefix(prefix) + ": ";
-  if (subject) {
-    commitMessage += StringUtils.capitalize(subject);
+}
+const _CommitLinter = class _CommitLinter {
+  constructor(config) {
+    __privateAdd(this, _CommitLinter_instances);
+    __privateAdd(this, _config);
+    __privateSet(this, _config, config);
   }
-  if (comments.length > 0) {
-    commitMessage += "\n\n#" + comments.join("\n#");
+  /**
+   * Initializes the CommitLinter with the loaded commitlint configuration.
+   *
+   * @returns A Promise that resolves to an instance of CommitLinter.
+   */
+  static async init() {
+    const config = await loadCommitlintConfig();
+    return new _CommitLinter(config);
+  }
+  /**
+   * Lints commit messages using commitlint.
+   *
+   * @param args - An array of arguments to pass to commitlint.
+   * @returns The exit status of the commitlint command.
+   */
+  static lint(args) {
+    const { status } = ChildProcess.spawnSync("commitlint", args, { stdio: "inherit" });
+    return status ?? 0;
+  }
+  /**
+   * Parses a semantic branch name into its type and scope.
+   *
+   * @param name - The branch name to parse.
+   * @returns An object containing the type and scope of the commit message.
+   * @throws An error if the branch name is invalid.
+   */
+  parseSemanticBranchName(name) {
+    const [typeValue, scopeValue] = name.split("-");
+    if (!typeValue || !__privateMethod(this, _CommitLinter_instances, isValidType_fn).call(this, typeValue)) {
+      throw new Error("Invalid commit type in branch name");
+    }
+    const type = typeValue.toLowerCase();
+    const scope = scopeValue && __privateMethod(this, _CommitLinter_instances, isValidScope_fn).call(this, scopeValue) ? scopeValue.toLowerCase() : null;
+    return {
+      type,
+      scope
+    };
+  }
+  /**
+   * Returns the prefix of a semantic commit message as a string.
+   *
+   * This prefix consists of the type and scope of the commit message.
+   * If the scope is not provided, it will only return the type.
+   * @param prefix - An object containing the type and scope of the commit message.
+   * @returns
+   */
+  static stringifySemanticCommitMessagePrefix({ type, scope }) {
+    return `${type}${scope ? `(${scope})` : ""}`;
+  }
+  /**
+   * Formats a semantic commit message by capitalizing the content after the prefix.
+   *
+   * @param message - The commit message to format.
+   * @returns The formatted commit message.
+   */
+  static formatSemanticCommitMessage(message) {
+    const { prefix, content } = __privateMethod(this, _CommitLinter_static, parseSemanticCommitMessage_fn).call(this, message);
+    if (!prefix || !content) {
+      return message;
+    }
+    return `${prefix}: ${StringUtils.capitalize(content)}`;
+  }
+  /**
+   * Creates a semantic commit message from a prefix and a message.
+   *
+   * @param prefix - The prefix of the commit message, containing type and scope.
+   * @param message - The content of the commit message.
+   * @returns The formatted semantic commit message.
+   */
+  static createSemanticCommitMessage(prefix, message) {
+    const [subject, ...comments] = message.split("\n#");
+    let commitMessage = this.stringifySemanticCommitMessagePrefix(prefix) + ": ";
+    if (subject) {
+      commitMessage += StringUtils.capitalize(subject);
+    }
+    if (comments.length > 0) {
+      commitMessage += "\n\n#" + comments.join("\n#");
+    }
+    return commitMessage;
   }
-  return commitMessage;
 };
-const isValidEnumValue = async (ruleName, value) => {
-  const { rules } = await loadCommitlintConfig();
-  const rule = rules[ruleName];
+_config = new WeakMap();
+_CommitLinter_instances = new WeakSet();
+isValidEnumValue_fn = function(ruleName, value) {
+  const rule = __privateGet(this, _config).rules[ruleName];
   if (!rule) {
     return true;
   }
@@ -64,43 +153,21 @@ const isValidEnumValue = async (ruleName, value) => {
   }
   return values.includes(value);
 };
-const isValidType = (type) => isValidEnumValue("type-enum", type);
-const isValidScope = (scope) => isValidEnumValue("scope-enum", scope);
-const CommitLintConfig = {
-  isValidType,
-  isValidScope
+isValidType_fn = function(type) {
+  return __privateMethod(this, _CommitLinter_instances, isValidEnumValue_fn).call(this, "type-enum", type);
 };
-const parseSemanticBranchName = async (name) => {
-  const [typeValue, scopeValue] = name.split("-");
-  if (!typeValue || !await CommitLintConfig.isValidType(typeValue)) {
-    throw new Error("Invalid commit type in branch name");
-  }
-  const type = typeValue.toLowerCase();
-  const scope = scopeValue && await CommitLintConfig.isValidScope(scopeValue) ? scopeValue.toLowerCase() : null;
-  return {
-    type,
-    scope
-  };
+isValidScope_fn = function(scope) {
+  return __privateMethod(this, _CommitLinter_instances, isValidEnumValue_fn).call(this, "scope-enum", scope);
 };
-const parseSemanticCommitMessage = (message) => {
+_CommitLinter_static = new WeakSet();
+parseSemanticCommitMessage_fn = function(message) {
   const firstColonPosition = message.search(":");
   const prefix = message.slice(0, firstColonPosition).trim();
   const content = message.slice(firstColonPosition + 1).trim();
   return { prefix, content };
 };
-const formatSemanticCommitMessage = (message) => {
-  const { prefix, content } = parseSemanticCommitMessage(message);
-  if (!prefix || !content) {
-    return message;
-  }
-  return `${prefix}: ${StringUtils.capitalize(content)}`;
-};
-const CommitLintCommands = {
-  createSemanticCommitMessage,
-  parseSemanticBranchName,
-  formatSemanticCommitMessage,
-  startsWithSemanticCommitMessagePrefix
-};
+__privateAdd(_CommitLinter, _CommitLinter_static);
+let CommitLinter = _CommitLinter;
 const commitMessagePathArgSchema = z.string();
 const parseFormatCommitMessageArgs = ([commitMessagePathArg]) => {
   const commitMessagePath = commitMessagePathArgSchema.parse(commitMessagePathArg);
@@ -111,19 +178,21 @@ const parseFormatCommitMessageArgs = ([commitMessagePathArg]) => {
 const main = async (args) => {
   try {
     const { commitMessagePath } = parseFormatCommitMessageArgs(args);
-    const commitMessage = (await FileSystem.readFile(commitMessagePath)).toString();
-    const formattedCommitMessage = CommitLintCommands.formatSemanticCommitMessage(commitMessage);
+    const commitMessageBuffer = await FileSystem.readFile(commitMessagePath);
+    const commitMessage = commitMessageBuffer.toString();
+    const formattedCommitMessage = CommitLinter.formatSemanticCommitMessage(commitMessage);
     if (formattedCommitMessage !== commitMessage) {
       await FileSystem.writeFile(commitMessagePath, formattedCommitMessage);
     }
   } catch (error) {
     if (error instanceof ZodError) {
-      console.warn("Invalid commit message path");
+      console.warn("Warning: Invalid commit message path");
     }
     if (error instanceof Error) {
-      console.warn(error.message);
+      console.warn("Warning:", error.message);
+    } else {
+      console.warn("Warning:", error);
     }
-    console.warn(error);
   }
   return 0;
 };