@cluerise/tools 3.0.1 → 4.0.1

package/dist/scripts/lint/main.js

@@ -1,10 +1,105 @@
+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 _packageName, _CoreConfig_static, rootDirectory_get, _command, _ConsoleStatusLogger_static, createResultMessage_fn, _config, _CommitLinter_instances, isValidEnumValue_fn, isValidType_fn, isValidScope_fn, _CommitLinter_static, parseSemanticCommitMessage_fn, _options, _eslint, _eslintFixer, _FileLinter_static, preparePrettierLintResult_fn, _FileLinter_instances, prettierLint_fn, prepareESLintLintResult_fn, eslintLint_fn;
+import Path from "node:path";
 import { z, ZodError } from "zod";
-import ChildProcess from "child_process";
+import ChildProcess from "node:child_process";
+import loadCommitlintConfig from "@commitlint/load";
+import FileSystem from "node:fs/promises";
+import OS from "node:os";
 import { ESLint } from "eslint";
-import FileSystem from "fs/promises";
 import { glob } from "glob";
 import * as Prettier from "prettier";
-import "@commitlint/load";
+class CoreConfig {
+  /**
+   * Determines if the application is running in production mode.
+   *
+   * This is based on the environment variable `import.meta.env.PROD`.
+   *
+   * @returns True if in production mode, false otherwise.
+   */
+  static get isProd() {
+    return true;
+  }
+  /**
+   * Returns the package and its path to the configuration files.
+   *
+   * This is used to load configurations from the package in production mode.
+   *
+   * @returns The path to the configuration files in the package.
+   */
+  static get configPackage() {
+    return `${__privateGet(this, _packageName)}/dist/configs`;
+  }
+  /**
+   * Returns the directory where configuration files are stored.
+   *
+   * In production mode, this points to the `dist/configs` directory within the package.
+   * In development mode, it points to the root directory.
+   *
+   * @returns The path to the configuration directory.
+   */
+  static get configDirectory() {
+    return this.isProd ? `${__privateGet(this, _CoreConfig_static, rootDirectory_get)}/dist/configs` : __privateGet(this, _CoreConfig_static, rootDirectory_get);
+  }
+}
+_packageName = new WeakMap();
+_CoreConfig_static = new WeakSet();
+rootDirectory_get = function() {
+  return this.isProd ? `./node_modules/${__privateGet(this, _packageName)}` : ".";
+};
+__privateAdd(CoreConfig, _CoreConfig_static);
+__privateAdd(CoreConfig, _packageName, "@cluerise/tools");
+const _ConsoleStatusLogger = class _ConsoleStatusLogger {
+  constructor(command) {
+    __privateAdd(this, _command);
+    __privateSet(this, _command, command);
+  }
+  /**
+   * Begins logging for a command with the specified argument.
+   *
+   * @param argument - The argument for the command.
+   *
+   * @example
+   * const logger = new ConsoleStatusLogger('Linting');
+   * logger.begin('src/index.ts'); // Logs: "Linting src/index.ts..."
+   */
+  begin(argument) {
+    console.info(`${__privateGet(this, _command)} ${argument}...`);
+  }
+  /**
+   * Ends logging for a command with the specified argument and exit code.
+   *
+   * @param argument - The argument for the command.
+   * @param exitCode - The exit code of the command execution. If null, it indicates completion without an error.
+   *
+   * @example
+   * const logger = new ConsoleStatusLogger('Linting');
+   * logger.end('src/index.ts'); // Logs: "Linting src/index.ts... Done"
+   * logger.end('src/index.ts', 0); // Logs: "Linting src/index.ts... OK"
+   * logger.end('src/index.ts', 1); // Logs: "Linting src/index.ts... Failed"
+   */
+  end(argument, exitCode = null) {
+    var _a;
+    console.info(`${__privateGet(this, _command)} ${argument}... ${__privateMethod(_a = _ConsoleStatusLogger, _ConsoleStatusLogger_static, createResultMessage_fn).call(_a, exitCode)}`);
+  }
+};
+_command = new WeakMap();
+_ConsoleStatusLogger_static = new WeakSet();
+createResultMessage_fn = function(exitCode) {
+  if (exitCode === null) {
+    return "Done";
+  }
+  return exitCode === 0 ? "OK" : "Failed";
+};
+__privateAdd(_ConsoleStatusLogger, _ConsoleStatusLogger_static);
+let ConsoleStatusLogger = _ConsoleStatusLogger;
 const enginesSchema = z.object({
   node: z.string()
 });
@@ -22,139 +117,347 @@ 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 createResultMessage = (exitCode) => {
-  if (exitCode === null) {
-    return "Done";
+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)}`;
+  }
+}
+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 exitCode === 0 ? "OK" : "Failed";
 };
-const createStatusConsole = (command) => ({
-  printBegin: (arg) => console.info(`${command} ${arg}...`),
-  printEnd: (arg, exitCode = null) => console.info(`${command} ${arg}... ${createResultMessage(exitCode)}`)
-});
-const lintCommit = (args) => {
-  const { status } = ChildProcess.spawnSync("commitlint", args, { stdio: "inherit" });
-  return status ?? 0;
+_config = new WeakMap();
+_CommitLinter_instances = new WeakSet();
+isValidEnumValue_fn = function(ruleName, value) {
+  const rule = __privateGet(this, _config).rules[ruleName];
+  if (!rule) {
+    return true;
+  }
+  const [_severity, _condition, values] = rule;
+  if (!values) {
+    return true;
+  }
+  return values.includes(value);
+};
+isValidType_fn = function(type) {
+  return __privateMethod(this, _CommitLinter_instances, isValidEnumValue_fn).call(this, "type-enum", type);
 };
-const lintFilesScopeShortcutSchema = z.union([z.literal("all"), z.literal("code")]);
-const scopePatterns = {
-  all: ["**"],
-  code: ["src/**"]
+isValidScope_fn = function(scope) {
+  return __privateMethod(this, _CommitLinter_instances, isValidEnumValue_fn).call(this, "scope-enum", scope);
 };
-const scopeShortcuts = Object.keys(scopePatterns);
-const isScopeShortcut = (scope) => scopeShortcuts.includes(scope);
-const resolveScope = (scope) => {
-  if (Array.isArray(scope)) {
-    return scope;
+_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 };
+};
+__privateAdd(_CommitLinter, _CommitLinter_static);
+let CommitLinter = _CommitLinter;
+const _FileLinter = class _FileLinter {
+  constructor(options) {
+    __privateAdd(this, _FileLinter_instances);
+    __privateAdd(this, _options);
+    __privateAdd(this, _eslint);
+    __privateAdd(this, _eslintFixer, null);
+    __privateSet(this, _options, options ?? null);
+    __privateSet(this, _eslint, new ESLint({
+      overrideConfigFile: options == null ? void 0 : options.configPath
+    }));
+    if (options == null ? void 0 : options.fix) {
+      __privateSet(this, _eslintFixer, new ESLint({
+        fix: options.fix,
+        overrideConfigFile: options == null ? void 0 : options.configPath
+      }));
+    }
   }
-  if (isScopeShortcut(scope)) {
-    return scopePatterns[scope];
+  /**
+   * Lints files using `lint-staged` with the provided arguments.
+   *
+   * @param args - An array of arguments to pass to `lint-staged`.
+   * @returns The exit status of the `lint-staged` command.
+   */
+  static lintStaged(args) {
+    const { status } = ChildProcess.spawnSync("lint-staged", args, { stdio: "inherit" });
+    return status ?? 0;
+  }
+  /**
+   * Lints files matching the provided patterns using ESLint and Prettier.
+   *
+   * @param patterns - An array of glob patterns to match files against. Defaults to ['**'] which matches all files.
+   * @returns A promise that resolves to a LintFilesResult indicating the success or failure of the linting process.
+   */
+  async lint(patterns = ["**"]) {
+    var _a;
+    const prettierResults = await __privateMethod(this, _FileLinter_instances, prettierLint_fn).call(this, patterns);
+    const eslintResults = await __privateMethod(this, _FileLinter_instances, eslintLint_fn).call(this, patterns);
+    const eslintResult = await __privateMethod(this, _FileLinter_instances, prepareESLintLintResult_fn).call(this, eslintResults);
+    if (eslintResult.status === "failure") {
+      return eslintResult;
+    }
+    const prettierResult = __privateMethod(_a = _FileLinter, _FileLinter_static, preparePrettierLintResult_fn).call(_a, prettierResults);
+    if (prettierResult.status === "failure") {
+      return prettierResult;
+    }
+    return {
+      status: "success"
+    };
   }
-  return [scope];
 };
-const formatWithPrettier = async (patterns) => {
-  const eslint = new ESLint();
+_options = new WeakMap();
+_eslint = new WeakMap();
+_eslintFixer = new WeakMap();
+_FileLinter_static = new WeakSet();
+preparePrettierLintResult_fn = function(results) {
+  if (results.length === 0) {
+    return { status: "success" };
+  }
+  const title = `Linting with Prettier failed with ${results.length} problem${results.length === 1 ? "" : "s"}
+`;
+  let message = "Prettier failed with the following files:\n";
+  message += results.map((result) => `- ${result.path}`).join("\n");
+  message += OS.EOL;
+  return {
+    status: "failure",
+    title,
+    message,
+    problemCount: results.length
+  };
+};
+_FileLinter_instances = new WeakSet();
+prettierLint_fn = async function(patterns) {
   const configPath = await Prettier.resolveConfigFile();
   if (!configPath) {
-    return false;
+    return [];
   }
   const config = await Prettier.resolveConfig(configPath);
   if (!config) {
-    return false;
+    return [];
   }
   const paths = await glob(patterns, {
     nodir: true,
     ignore: "node_modules/**"
   });
-  await Promise.all(
+  const results = await Promise.all(
     paths.map(async (path) => {
-      if (await eslint.isPathIgnored(path)) {
-        return;
+      var _a;
+      if (await __privateGet(this, _eslint).isPathIgnored(path)) {
+        return null;
+      }
+      const contentBuffer = await FileSystem.readFile(path);
+      const content = contentBuffer.toString();
+      if ((_a = __privateGet(this, _options)) == null ? void 0 : _a.fix) {
+        const nextContent = await Prettier.format(content, {
+          ...config,
+          filepath: path
+        });
+        await FileSystem.writeFile(path, nextContent);
+        return null;
       }
-      const prevContent = (await FileSystem.readFile(path)).toString();
-      const nextContent = await Prettier.format(prevContent, {
+      const result = await Prettier.check(content, {
         ...config,
         filepath: path
       });
-      await FileSystem.writeFile(path, nextContent);
+      return result ? null : { path };
     })
   );
+  return results.filter((result) => result !== null);
 };
-const lintFiles = async (scope, options) => {
-  const patterns = resolveScope(scope);
-  if (options == null ? void 0 : options.fix) {
-    await formatWithPrettier(patterns);
-  }
-  const eslint = new ESLint({
-    fix: options == null ? void 0 : options.fix
-  });
-  const results = await eslint.lintFiles(patterns);
-  const problemCount = results.reduce((sum, result) => sum + result.errorCount + result.warningCount, 0);
-  if (options == null ? void 0 : options.fix) {
-    await ESLint.outputFixes(results);
-  }
-  if (problemCount > 0) {
-    const formatter = await eslint.loadFormatter("stylish");
-    const resultText = formatter.format(results);
-    console.error(resultText);
-    const errorMessage = `Linting failed with ${problemCount} problem${problemCount === 1 ? "" : "s"}.`;
-    throw new Error(errorMessage);
+prepareESLintLintResult_fn = async function(results) {
+  const problemCount = results.reduce(
+    (sum, result) => {
+      var _a;
+      return sum + result.errorCount + result.warningCount + (((_a = __privateGet(this, _options)) == null ? void 0 : _a.fix) ? -(result.fixableErrorCount + result.fixableWarningCount) : 0);
+    },
+    0
+  );
+  if (problemCount === 0) {
+    return { status: "success" };
   }
+  const title = `ESLint failed with ${problemCount} problem${problemCount === 1 ? "" : "s"}`;
+  const formatter = await __privateGet(this, _eslint).loadFormatter("stylish");
+  const message = await formatter.format(results);
+  return {
+    status: "failure",
+    title,
+    message,
+    problemCount
+  };
 };
-const lintStaged = (args) => {
-  const { status } = ChildProcess.spawnSync("lint-staged", args, { stdio: "inherit" });
-  return status ?? 0;
-};
-const LintCommands = {
-  lintFiles,
-  lintCommit,
-  lintStaged
+eslintLint_fn = async function(patterns) {
+  const results = await __privateGet(this, _eslint).lintFiles(patterns);
+  const errorResults = ESLint.getErrorResults(results);
+  if (__privateGet(this, _eslintFixer) && errorResults.length > 0) {
+    await ESLint.outputFixes(await __privateGet(this, _eslintFixer).lintFiles(patterns));
+  }
+  return results;
 };
-const lintScopeArgSchema = z.union([lintFilesScopeShortcutSchema, z.literal("commit"), z.literal("staged")]);
+__privateAdd(_FileLinter, _FileLinter_static);
+let FileLinter = _FileLinter;
+const lintScopeArgSchema = z.union([z.literal("all"), z.literal("fix"), z.literal("commit"), z.literal("staged")]);
 const parseLintArgs = ([scopeArg]) => {
   const scope = lintScopeArgSchema.parse(scopeArg);
   return {
     scope
   };
 };
-const lintingConsole = createStatusConsole("Linting");
 const main = async (args) => {
   try {
     const { scope } = parseLintArgs(args);
-    lintingConsole.printBegin(scope);
+    const statusLogger = new ConsoleStatusLogger("Linting");
+    statusLogger.begin(scope);
     if (scope === "commit") {
-      const exitCode = LintCommands.lintCommit(args.slice(1));
-      lintingConsole.printEnd(scope, exitCode);
+      const exitCode = CommitLinter.lint(args.slice(1));
+      statusLogger.end(scope, exitCode);
       return exitCode;
     }
     if (scope === "staged") {
-      const exitCode = LintCommands.lintStaged(args.slice(1));
-      lintingConsole.printEnd(scope, exitCode);
+      const exitCode = FileLinter.lintStaged(args.slice(1));
+      statusLogger.end(scope, exitCode);
       return exitCode;
     }
-    await LintCommands.lintFiles(scope);
-    lintingConsole.printEnd(scope);
+    const fix = scope === "fix";
+    const fileLinter = new FileLinter({ fix });
+    const lintStatus = await fileLinter.lint();
+    if (lintStatus.status === "failure") {
+      console.error(lintStatus.title);
+      console.error(lintStatus.message);
+      statusLogger.end(scope, 1);
+      return 1;
+    }
+    const markdownLinter = new FileLinter({
+      configPath: Path.join(CoreConfig.configDirectory, "eslint-markdown.config.js"),
+      fix
+    });
+    try {
+      const markdownLintStatus = await markdownLinter.lint(["**/*.md"]);
+      if (markdownLintStatus.status === "failure") {
+        console.error(markdownLintStatus.title);
+        console.error(markdownLintStatus.message);
+        statusLogger.end(scope, 1);
+        return 1;
+      }
+    } catch (error) {
+      const allFilesIgnoredError = error instanceof Error && "messageTemplate" in error && error.messageTemplate === "all-matched-files-ignored";
+      if (!allFilesIgnoredError) {
+        throw error;
+      }
+    }
+    statusLogger.end(scope);
     return 0;
   } catch (error) {
     if (error instanceof ZodError) {
       const firstIssue = error.issues[0];
       if ((firstIssue == null ? void 0 : firstIssue.code) === "invalid_union") {
-        console.error("Invalid scope");
+        console.error("Error: Invalid scope");
         return 1;
       }
     }
     if (error instanceof Error) {
-      console.error(error.message);
-      return 1;
+      console.error("Error:", error.message);
+    } else {
+      console.error("Error:", error);
     }
-    console.error(error);
     return 1;
   }
 };