@cluerise/tools 3.0.0 → 4.0.0

package/dist/scripts/check-heroku-node-version/main.js

@@ -1,25 +1,135 @@
+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 _origins, _names, _data, _PackageJson_instances, parseGitRepository_fn, _nodeReleasesUrl;
 import SemVer from "semver";
-import FileSystem from "fs/promises";
+import FileSystem from "node:fs/promises";
 import { z } from "zod";
 import { parse } from "smol-toml";
-class ParseGitRepositoryError extends Error {
-}
 const gitProviderOrigins = {
   github: "https://github.com"
 };
-const gitProviderNames = Object.keys(gitProviderOrigins);
-const isGitProviderName = (name) => gitProviderNames.includes(name);
-const parseRepositoryUrl = (urlString) => {
+const _GitProvider = class _GitProvider {
+  /**
+   * Checks if the provided name is a valid Git provider name.
+   *
+   * @param name - The name of the Git provider to validate.
+   * @returns True if the name is valid, false otherwise.
+   */
+  static isValidName(name) {
+    return __privateGet(this, _names).includes(name);
+  }
+  /**
+   * Returns a Git provider origin.
+   *
+   * @param name - The name of the Git provider.
+   * @returns The origin URL of the Git provider.
+   */
+  static getOrigin(name) {
+    return __privateGet(this, _origins)[name];
+  }
+};
+_origins = new WeakMap();
+_names = new WeakMap();
+__privateAdd(_GitProvider, _origins, gitProviderOrigins);
+__privateAdd(_GitProvider, _names, Object.keys(__privateGet(_GitProvider, _origins)));
+let GitProvider = _GitProvider;
+const enginesSchema = z.object({
+  node: z.string()
+});
+const repositoryObjectSchema = z.object({
+  type: z.string(),
+  url: z.string(),
+  directory: z.ostring()
+});
+const repositorySchema = z.union([z.string(), repositoryObjectSchema]);
+const packageJsonDataSchema = z.object({
+  name: z.string(),
+  version: z.string(),
+  description: z.string(),
+  engines: enginesSchema.optional(),
+  repository: repositorySchema.optional()
+});
+const _PackageJson = class _PackageJson {
+  constructor(data) {
+    __privateAdd(this, _PackageJson_instances);
+    __privateAdd(this, _data);
+    __privateSet(this, _data, data);
+  }
+  static async init() {
+    const content = await FileSystem.readFile("package.json", { encoding: "utf8" });
+    const data = JsonUtils.parse(content);
+    const parseResult = packageJsonDataSchema.safeParse(data);
+    if (!parseResult.success) {
+      throw new Error("Invalid package.json", {
+        cause: parseResult.error
+      });
+    }
+    return new _PackageJson(parseResult.data);
+  }
+  /**
+   * Returns the required engines.
+   */
+  get engines() {
+    return __privateGet(this, _data).engines;
+  }
+  /**
+   * Sets the required engines.
+   *
+   * @param engines - The engines to set.
+   */
+  set engines(engines) {
+    __privateGet(this, _data).engines = engines;
+  }
+  /**
+   * Returns the repository information.
+   */
+  get repository() {
+    return __privateGet(this, _data).repository;
+  }
+  /**
+   * Parses the repository information from package.json.
+   *
+   * @returns The parsed GitRepository or null if no repository is defined.
+   */
+  parseGitRepository() {
+    if (!this.repository) {
+      return null;
+    }
+    if (typeof this.repository === "string") {
+      return __privateMethod(this, _PackageJson_instances, parseGitRepository_fn).call(this, this.repository);
+    }
+    return __privateMethod(this, _PackageJson_instances, parseGitRepository_fn).call(this, this.repository.url);
+  }
+  /**
+   * Saves the package.json file with the current data.
+   */
+  async save() {
+    const content = JsonUtils.prettify(__privateGet(this, _data)) + "\n";
+    await FileSystem.writeFile("package.json", content, { encoding: "utf8" });
+  }
+};
+_data = new WeakMap();
+_PackageJson_instances = new WeakSet();
+parseGitRepository_fn = function(urlString) {
+  if (!urlString) {
+    return null;
+  }
   const urlValue = urlString.includes(":") ? urlString : `https://${urlString}`;
   const url = new URL(urlValue);
   const scheme = url.protocol.slice(0, -1);
-  if (isGitProviderName(scheme)) {
+  if (GitProvider.isValidName(scheme)) {
     const [owner, repositoryName] = url.pathname.split("/");
     if (!owner || !repositoryName) {
-      throw new ParseGitRepositoryError("Unknown owner or repositoryName");
+      throw new Error("Unknown owner or repositoryName");
     }
     return {
-      origin: gitProviderOrigins[scheme],
+      origin: GitProvider.getOrigin(scheme),
       owner,
       repositoryName
     };
@@ -27,7 +137,7 @@ const parseRepositoryUrl = (urlString) => {
   if (scheme === "https") {
     const [, owner, repositoryName] = url.pathname.split("/");
     if (!owner || !repositoryName) {
-      throw new ParseGitRepositoryError("Unknown owner or repositoryName");
+      throw new Error("Unknown owner or repositoryName");
     }
     return {
       origin: url.origin,
@@ -35,52 +145,28 @@ const parseRepositoryUrl = (urlString) => {
       repositoryName: repositoryName.endsWith(".git") ? repositoryName.slice(0, -4) : repositoryName
     };
   }
-  throw new ParseGitRepositoryError("Unsupported repository URL");
-};
-const parsePackageJsonRepository = (repository) => {
-  if (typeof repository === "string") {
-    return parseRepositoryUrl(repository);
-  }
-  return parseRepositoryUrl(repository.url);
-};
-const enginesSchema = z.object({
-  node: z.string()
-});
-const repositoryObjectSchema = z.object({
-  type: z.string(),
-  url: z.string(),
-  directory: z.ostring()
-});
-const repositorySchema = z.union([z.string(), repositoryObjectSchema]);
-const packageJsonSchema = z.object({
-  name: z.string(),
-  version: z.string(),
-  description: z.string(),
-  engines: enginesSchema.optional(),
-  repository: repositorySchema.optional()
-});
-const readPackageJson = async () => {
-  const packageJsonData = await FileSystem.readFile("package.json", { encoding: "utf8" });
-  const packageJson = JSON.parse(packageJsonData);
-  const parseResult = packageJsonSchema.safeParse(packageJson);
-  if (!parseResult.success) {
-    throw parseResult.error;
-  }
-  return packageJson;
-};
-const CoreCommands = {
-  readPackageJson,
-  parsePackageJsonRepository
+  throw new Error("Unsupported repository URL");
 };
+let PackageJson = _PackageJson;
 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 herokuNodeReleasesUrl = "https://raw.githubusercontent.com/heroku/heroku-buildpack-nodejs/latest/inventory/node.toml";
+class JsonUtils {
+  static stringify(value) {
+    return JSON.stringify(value);
+  }
+  static prettify(value) {
+    return JSON.stringify(value, null, 2);
+  }
+  static parse(value) {
+    return JSON.parse(value);
+  }
+}
 const herokuNodeReleaseSchema = z.object({
   version: z.string(),
   channel: z.string(),
@@ -92,16 +178,22 @@ const herokuNodeReleasesSchema = z.object({
   name: z.string(),
   releases: z.array(herokuNodeReleaseSchema)
 });
-const fetchNodeReleases = async () => {
-  const response = await fetch(herokuNodeReleasesUrl);
-  const data = await response.text();
-  const releasesData = parse(data);
-  const { releases } = herokuNodeReleasesSchema.parse(releasesData);
-  return releases;
-};
-const HerokuCommands = {
-  fetchNodeReleases
-};
+class Heroku {
+  /**
+   * Fetches supported Node.js releases on Heroku.
+   *
+   * @returns A promise that resolves to an array of HerokuNodeRelease objects.
+   */
+  static async fetchNodeReleases() {
+    const response = await fetch(__privateGet(this, _nodeReleasesUrl));
+    const data = await response.text();
+    const releasesData = parse(data);
+    const { releases } = herokuNodeReleasesSchema.parse(releasesData);
+    return releases;
+  }
+}
+_nodeReleasesUrl = new WeakMap();
+__privateAdd(Heroku, _nodeReleasesUrl, "https://raw.githubusercontent.com/heroku/heroku-buildpack-nodejs/latest/inventory/node.toml");
 const getResultMessage = (nodeVersion, supported) => {
   const nodeVersionIsRange = SemVer.valid(nodeVersion) === null;
   const name = `Node.js version ${nodeVersionIsRange ? `range "${nodeVersion}"` : nodeVersion}`;
@@ -110,7 +202,7 @@ const getResultMessage = (nodeVersion, supported) => {
 const main = async () => {
   var _a;
   try {
-    const packageJson = await CoreCommands.readPackageJson();
+    const packageJson = await PackageJson.init();
     const nodeVersion = (_a = packageJson.engines) == null ? void 0 : _a.node;
     if (!nodeVersion) {
       console.error("Error: Node.js version is not specified in package.json");
@@ -121,13 +213,13 @@ const main = async () => {
       console.error(`Error: Node.js version "${nodeVersion}" is not valid semver version or range`);
       return 1;
     }
-    const releases = await HerokuCommands.fetchNodeReleases();
+    const releases = await Heroku.fetchNodeReleases();
     const nodeVersionIsSupported = releases.some((release) => SemVer.satisfies(release.version, nodeVersion));
     if (!nodeVersionIsSupported) {
       console.error(`Error: ${getResultMessage(nodeVersion, false)}`);
       return 1;
     }
-    console.log(`Info: ${getResultMessage(nodeVersion, true)}`);
+    console.info(`Info: ${getResultMessage(nodeVersion, true)}`);
     return 0;
   } catch (error) {
     console.error("Error: Cannot check Node.js version on Heroku");

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

@@ -1,10 +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 "child_process";
+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()
 });
@@ -22,53 +31,142 @@ 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
-};
-const getBranchName = () => ChildProcess.execSync("git symbolic-ref --short HEAD").toString().trim();
-const isRebasing = () => {
-  try {
-    ChildProcess.execSync("ls `git rev-parse --git-dir` | grep rebase");
-    return true;
-  } catch {
-    return false;
+}
+class Git {
+  /**
+   * Returns the current branch name of the git repository.
+   *
+   * @returns The name of the current branch.
+   */
+  static getBranchName() {
+    return ChildProcess.execSync("git symbolic-ref --short HEAD").toString().trim();
   }
-};
-const GitCommands = {
-  getBranchName,
-  isRebasing
-};
-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);
+  /**
+   * Checks if the repository is currently in a rebase state.
+   *
+   * @returns True if the repository is rebasing, false otherwise.
+   */
+  static isRebasing() {
+    try {
+      ChildProcess.execSync("ls `git rev-parse --git-dir` | grep rebase");
+      return true;
+    } catch {
+      return false;
+    }
   }
-  if (comments.length > 0) {
-    commitMessage += "\n\n#" + comments.join("\n#");
+}
+const _CommitLinter = class _CommitLinter {
+  constructor(config) {
+    __privateAdd(this, _CommitLinter_instances);
+    __privateAdd(this, _config);
+    __privateSet(this, _config, config);
+  }
+  /**
+   * 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;
   }
@@ -78,43 +176,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 parseCreateCommitMessageArgs = ([commitMessagePathArg]) => {
   const commitMessagePath = commitMessagePathArgSchema.parse(commitMessagePathArg);
@@ -124,25 +200,27 @@ const parseCreateCommitMessageArgs = ([commitMessagePathArg]) => {
 };
 const main = async (args) => {
   try {
-    if (GitCommands.isRebasing()) {
+    if (Git.isRebasing()) {
       return 0;
     }
     const { commitMessagePath } = parseCreateCommitMessageArgs(args);
-    const commitMessage = (await FileSystem.readFile(commitMessagePath)).toString();
-    const branchName = GitCommands.getBranchName();
-    const commitMessagePrefix = await CommitLintCommands.parseSemanticBranchName(branchName);
-    if (!CommitLintCommands.startsWithSemanticCommitMessagePrefix(commitMessage, commitMessagePrefix)) {
-      const nextCommitMessage = CommitLintCommands.createSemanticCommitMessage(commitMessagePrefix, commitMessage);
+    const commitMessageBuffer = await FileSystem.readFile(commitMessagePath);
+    const commitMessage = commitMessageBuffer.toString();
+    const commitLinter = await CommitLinter.init();
+    const commitMessagePrefix = commitLinter.parseSemanticBranchName(Git.getBranchName());
+    if (!commitMessage.startsWith(CommitLinter.stringifySemanticCommitMessagePrefix(commitMessagePrefix))) {
+      const nextCommitMessage = CommitLinter.createSemanticCommitMessage(commitMessagePrefix, commitMessage);
       await FileSystem.writeFile(commitMessagePath, nextCommitMessage);
     }
   } 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;
 };