@cluerise/tools 3.0.1 → 4.0.1

package/dist/scripts/release/main.js

@@ -1,14 +1,23 @@
+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 _options, _eslint, _eslintFixer, _FileLinter_static, preparePrettierLintResult_fn, _FileLinter_instances, prettierLint_fn, prepareESLintLintResult_fn, eslintLint_fn, _releaseSeparator, _config, _changelogPath, _Releaser_static, findLastReleaseTitle_fn, prependReleaseNotes_fn;
 import * as ActionsCore from "@actions/core";
 import { z, ZodError } from "zod";
-import ChildProcess from "child_process";
-import FileSystem from "fs/promises";
-import Path from "path";
+import ChildProcess from "node:child_process";
+import FileSystem from "node:fs/promises";
+import OS from "node:os";
+import Path from "node:path";
 import semanticRelease from "semantic-release";
+import "@commitlint/load";
 import { ESLint } from "eslint";
 import { glob } from "glob";
 import * as Prettier from "prettier";
-import "@commitlint/load";
-import OS from "os";
 const enginesSchema = z.object({
   node: z.string()
 });
@@ -26,164 +35,253 @@ 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 lintCommit = (args) => {
-  const { status } = ChildProcess.spawnSync("commitlint", args, { stdio: "inherit" });
-  return status ?? 0;
-};
-z.union([z.literal("all"), z.literal("code")]);
-const scopePatterns = {
-  all: ["**"],
-  code: ["src/**"]
-};
-const scopeShortcuts = Object.keys(scopePatterns);
-const isScopeShortcut = (scope) => scopeShortcuts.includes(scope);
-const resolveScope = (scope) => {
-  if (Array.isArray(scope)) {
-    return scope;
+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
+      }));
+    }
+  }
+  /**
+   * 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"
+    };
   }
-  if (isScopeShortcut(scope)) {
-    return scopePatterns[scope];
+};
+_options = new WeakMap();
+_eslint = new WeakMap();
+_eslintFixer = new WeakMap();
+_FileLinter_static = new WeakSet();
+preparePrettierLintResult_fn = function(results) {
+  if (results.length === 0) {
+    return { status: "success" };
   }
-  return [scope];
+  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
+  };
 };
-const formatWithPrettier = async (patterns) => {
-  const eslint = new ESLint();
+_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;
+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 LintCommands = {
-  lintFiles,
-  lintCommit,
-  lintStaged
+__privateAdd(_FileLinter, _FileLinter_static);
+let FileLinter = _FileLinter;
+const _Releaser = class _Releaser {
+  constructor(config, changelogPath) {
+    __privateAdd(this, _config);
+    __privateAdd(this, _changelogPath);
+    __privateSet(this, _config, config);
+    __privateSet(this, _changelogPath, changelogPath);
+  }
+  /**
+   * Initializes a new instance of the Releaser class with the provided configuration.
+   *
+   * The configuration is loaded from a specified file path, and the changelog path is set.
+   *
+   * @param options - Options for initializing the releaser, including paths for the config and changelog.
+   * @param options.configPath - The path to the semantic-release configuration file. Defaults to 'release.config.js'.
+   * @param options.changelogPath - The path to the changelog file. Defaults to 'CHANGELOG.md'.
+   * @returns A new instance of Releaser.
+   */
+  static async init({
+    configPath = "release.config.js",
+    changelogPath = "CHANGELOG.md"
+  } = {}) {
+    const configAbsolutePath = Path.join(process.cwd(), configPath);
+    const { default: config } = await import(`file://${configAbsolutePath}`);
+    return new _Releaser(config, changelogPath);
+  }
+  /**
+   * Creates a new release based on the semantic-release configuration.
+   *
+   * It updates the changelog with the new release notes and runs linting on the changelog file.
+   *
+   * @returns The next release information or null if no release was created.
+   */
+  async createRelease() {
+    var _a;
+    const result = await semanticRelease(__privateGet(this, _config));
+    if (!result) {
+      return null;
+    }
+    const { lastRelease, nextRelease } = result;
+    const oldChangelogBuffer = await FileSystem.readFile(__privateGet(this, _changelogPath), { flag: FileSystem.constants.O_CREAT });
+    const oldChangelog = oldChangelogBuffer.toString();
+    const newChangelog = __privateMethod(_a = _Releaser, _Releaser_static, prependReleaseNotes_fn).call(_a, oldChangelog, lastRelease, nextRelease);
+    await FileSystem.writeFile(__privateGet(this, _changelogPath), newChangelog);
+    const linter = new FileLinter({ fix: true });
+    await linter.lint([__privateGet(this, _changelogPath)]);
+    ChildProcess.execFileSync("pnpm", ["version", nextRelease.version, "--no-git-tag-version"]);
+    return nextRelease;
+  }
+  /**
+   * Extracts the latest release changelog from the changelog file.
+   *
+   * @returns The content of the latest release changelog.
+   * @throws If no release is found or if the header is not found in the changelog.
+   */
+  async extractLatestReleaseChangelog() {
+    const contentBuffer = await FileSystem.readFile(__privateGet(this, _changelogPath));
+    const content = contentBuffer.toString();
+    const [, latestReleaseChangelog] = content.split(__privateGet(_Releaser, _releaseSeparator));
+    if (!latestReleaseChangelog) {
+      throw new Error("No release found");
+    }
+    const indexOfFirstEOL = latestReleaseChangelog.indexOf(OS.EOL);
+    if (indexOfFirstEOL === -1) {
+      throw new Error("Header not found");
+    }
+    return latestReleaseChangelog.slice(indexOfFirstEOL).trim();
+  }
 };
-const releaseConfigFilename = "release.config.js";
-const releaseNotesPath = "CHANGELOG.md";
-const findLastReleaseTitle = (releaseNotes, lastRelease) => {
+_releaseSeparator = new WeakMap();
+_config = new WeakMap();
+_changelogPath = new WeakMap();
+_Releaser_static = new WeakSet();
+findLastReleaseTitle_fn = function(changelog, lastRelease) {
   const lastReleaseTitleLink = `## [${lastRelease.version}](`;
-  if (releaseNotes.includes(lastReleaseTitleLink)) {
+  if (changelog.includes(lastReleaseTitleLink)) {
     return lastReleaseTitleLink;
   }
   const lastReleaseTitle = `## ${lastRelease.version}`;
-  if (releaseNotes.includes(lastReleaseTitle)) {
+  if (changelog.includes(lastReleaseTitle)) {
     return lastReleaseTitle;
   }
   return null;
 };
-const prependReleaseNotes = (releaseNotes, lastRelease, nextRelease) => {
+prependReleaseNotes_fn = function(changelog, lastRelease, nextRelease) {
   var _a;
   const nextReleaseNotes = ((_a = nextRelease.notes) == null ? void 0 : _a.trim()) ?? "";
-  if (releaseNotes.length === 0) {
+  if (changelog.length === 0) {
     return nextReleaseNotes;
   }
-  const lastReleaseTitle = findLastReleaseTitle(releaseNotes, lastRelease);
+  const lastReleaseTitle = __privateMethod(this, _Releaser_static, findLastReleaseTitle_fn).call(this, changelog, lastRelease);
   if (!lastReleaseTitle) {
     return nextReleaseNotes;
   }
-  return releaseNotes.replace(lastReleaseTitle, `${nextReleaseNotes}
+  return changelog.replace(lastReleaseTitle, `${nextReleaseNotes}
 
 ${lastReleaseTitle}`);
 };
-const createRelease = async () => {
-  const releaseConfigPath = Path.join(process.cwd(), releaseConfigFilename);
-  const { default: releaseConfig } = await import(`file://${releaseConfigPath}`);
-  const result = await semanticRelease(releaseConfig);
-  if (!result) {
-    return null;
-  }
-  const { lastRelease, nextRelease } = result;
-  const oldReleaseNotes = (await FileSystem.readFile(releaseNotesPath, {
-    flag: FileSystem.constants.O_CREAT
-  })).toString();
-  const newReleaseNotes = prependReleaseNotes(oldReleaseNotes, lastRelease, nextRelease);
-  await FileSystem.writeFile(releaseNotesPath, newReleaseNotes);
-  await LintCommands.lintFiles(releaseNotesPath, {
-    fix: true
-  });
-  ChildProcess.execFileSync("npm", [
-    "version",
-    nextRelease.version,
-    "--message",
-    "release: Version %s",
-    "--no-git-tag-version"
-  ]);
-  return nextRelease;
-};
-const releaseSeparator = /^## /gm;
-const extractChangelog = async () => {
-  const content = (await FileSystem.readFile("CHANGELOG.md")).toString();
-  const [, latestReleaseChangelog] = content.split(releaseSeparator);
-  if (!latestReleaseChangelog) {
-    throw new Error("No release found");
-  }
-  const indexOfFirstEOL = latestReleaseChangelog.indexOf(OS.EOL);
-  if (indexOfFirstEOL === -1) {
-    throw new Error("Header not found");
-  }
-  const body = latestReleaseChangelog.slice(indexOfFirstEOL).trim();
-  const changelog = {
-    body
-  };
-  return changelog;
-};
-const ReleaseCommands = {
-  createRelease,
-  extractChangelog
-};
+__privateAdd(_Releaser, _Releaser_static);
+__privateAdd(_Releaser, _releaseSeparator, /^## /gm);
+let Releaser = _Releaser;
 const commandNameArgSchema = z.union([z.literal("create"), z.literal("extract-changelog")]);
 const parseReleaseArgs = ([commandArg]) => {
   const command = commandNameArgSchema.parse(commandArg);
@@ -194,8 +292,9 @@ const parseReleaseArgs = ([commandArg]) => {
 const main = async (args) => {
   try {
     const { command } = parseReleaseArgs(args);
+    const releaser = await Releaser.init();
     if (command === "create") {
-      const release = await ReleaseCommands.createRelease();
+      const release = await releaser.createRelease();
       if (!release) {
         return 0;
       }
@@ -203,11 +302,11 @@ const main = async (args) => {
         ActionsCore.setOutput("version", release.version);
       }
     } else if (command === "extract-changelog") {
-      const changelog = await ReleaseCommands.extractChangelog();
+      const changelog = await releaser.extractLatestReleaseChangelog();
       if (process.env.GITHUB_ACTIONS === "true") {
-        ActionsCore.setOutput("changelog", changelog.body);
+        ActionsCore.setOutput("changelog", changelog);
       } else {
-        console.log(changelog.body);
+        console.log(changelog);
       }
     }
     return 0;
@@ -215,15 +314,15 @@ const main = async (args) => {
     if (error instanceof ZodError) {
       const firstIssue = error.issues[0];
       if ((firstIssue == null ? void 0 : firstIssue.code) === "invalid_union") {
-        console.error("Invalid command name");
+        console.error("Error: Invalid command name");
         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;
   }
 };