@cluerise/tools 3.0.0

package/dist/scripts/lint/main.js

@@ -0,0 +1,161 @@
+import { z, ZodError } from "zod";
+import ChildProcess from "child_process";
+import { ESLint } from "eslint";
+import FileSystem from "fs/promises";
+import { glob } from "glob";
+import * as Prettier from "prettier";
+import "@commitlint/load";
+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]);
+z.object({
+  name: z.string(),
+  version: z.string(),
+  description: z.string(),
+  engines: enginesSchema.optional(),
+  repository: repositorySchema.optional()
+});
+const runMain = (main2) => {
+  main2(process.argv.slice(2)).then((exitCode) => {
+    process.exit(exitCode);
+  }).catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+};
+const createResultMessage = (exitCode) => {
+  if (exitCode === null) {
+    return "Done";
+  }
+  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;
+};
+const lintFilesScopeShortcutSchema = 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;
+  }
+  if (isScopeShortcut(scope)) {
+    return scopePatterns[scope];
+  }
+  return [scope];
+};
+const formatWithPrettier = async (patterns) => {
+  const eslint = new ESLint();
+  const configPath = await Prettier.resolveConfigFile();
+  if (!configPath) {
+    return false;
+  }
+  const config = await Prettier.resolveConfig(configPath);
+  if (!config) {
+    return false;
+  }
+  const paths = await glob(patterns, {
+    nodir: true,
+    ignore: "node_modules/**"
+  });
+  await Promise.all(
+    paths.map(async (path) => {
+      if (await eslint.isPathIgnored(path)) {
+        return;
+      }
+      const prevContent = (await FileSystem.readFile(path)).toString();
+      const nextContent = await Prettier.format(prevContent, {
+        ...config,
+        filepath: path
+      });
+      await FileSystem.writeFile(path, nextContent);
+    })
+  );
+};
+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);
+  }
+};
+const lintStaged = (args) => {
+  const { status } = ChildProcess.spawnSync("lint-staged", args, { stdio: "inherit" });
+  return status ?? 0;
+};
+const LintCommands = {
+  lintFiles,
+  lintCommit,
+  lintStaged
+};
+const lintScopeArgSchema = z.union([lintFilesScopeShortcutSchema, 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);
+    if (scope === "commit") {
+      const exitCode = LintCommands.lintCommit(args.slice(1));
+      lintingConsole.printEnd(scope, exitCode);
+      return exitCode;
+    }
+    if (scope === "staged") {
+      const exitCode = LintCommands.lintStaged(args.slice(1));
+      lintingConsole.printEnd(scope, exitCode);
+      return exitCode;
+    }
+    await LintCommands.lintFiles(scope);
+    lintingConsole.printEnd(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");
+        return 1;
+      }
+    }
+    if (error instanceof Error) {
+      console.error(error.message);
+      return 1;
+    }
+    console.error(error);
+    return 1;
+  }
+};
+runMain(main);

package/dist/scripts/release/main.js

@@ -0,0 +1,230 @@
+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 semanticRelease from "semantic-release";
+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()
+});
+const repositoryObjectSchema = z.object({
+  type: z.string(),
+  url: z.string(),
+  directory: z.ostring()
+});
+const repositorySchema = z.union([z.string(), repositoryObjectSchema]);
+z.object({
+  name: z.string(),
+  version: z.string(),
+  description: z.string(),
+  engines: enginesSchema.optional(),
+  repository: repositorySchema.optional()
+});
+const runMain = (main2) => {
+  main2(process.argv.slice(2)).then((exitCode) => {
+    process.exit(exitCode);
+  }).catch((error) => {
+    console.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;
+  }
+  if (isScopeShortcut(scope)) {
+    return scopePatterns[scope];
+  }
+  return [scope];
+};
+const formatWithPrettier = async (patterns) => {
+  const eslint = new ESLint();
+  const configPath = await Prettier.resolveConfigFile();
+  if (!configPath) {
+    return false;
+  }
+  const config = await Prettier.resolveConfig(configPath);
+  if (!config) {
+    return false;
+  }
+  const paths = await glob(patterns, {
+    nodir: true,
+    ignore: "node_modules/**"
+  });
+  await Promise.all(
+    paths.map(async (path) => {
+      if (await eslint.isPathIgnored(path)) {
+        return;
+      }
+      const prevContent = (await FileSystem.readFile(path)).toString();
+      const nextContent = await Prettier.format(prevContent, {
+        ...config,
+        filepath: path
+      });
+      await FileSystem.writeFile(path, nextContent);
+    })
+  );
+};
+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);
+  }
+};
+const lintStaged = (args) => {
+  const { status } = ChildProcess.spawnSync("lint-staged", args, { stdio: "inherit" });
+  return status ?? 0;
+};
+const LintCommands = {
+  lintFiles,
+  lintCommit,
+  lintStaged
+};
+const releaseConfigFilename = "release.config.js";
+const releaseNotesPath = "CHANGELOG.md";
+const findLastReleaseTitle = (releaseNotes, lastRelease) => {
+  const lastReleaseTitleLink = `## [${lastRelease.version}](`;
+  if (releaseNotes.includes(lastReleaseTitleLink)) {
+    return lastReleaseTitleLink;
+  }
+  const lastReleaseTitle = `## ${lastRelease.version}`;
+  if (releaseNotes.includes(lastReleaseTitle)) {
+    return lastReleaseTitle;
+  }
+  return null;
+};
+const prependReleaseNotes = (releaseNotes, lastRelease, nextRelease) => {
+  var _a;
+  const nextReleaseNotes = ((_a = nextRelease.notes) == null ? void 0 : _a.trim()) ?? "";
+  if (releaseNotes.length === 0) {
+    return nextReleaseNotes;
+  }
+  const lastReleaseTitle = findLastReleaseTitle(releaseNotes, lastRelease);
+  if (!lastReleaseTitle) {
+    return nextReleaseNotes;
+  }
+  return releaseNotes.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
+};
+const commandNameArgSchema = z.union([z.literal("create"), z.literal("extract-changelog")]);
+const parseReleaseArgs = ([commandArg]) => {
+  const command = commandNameArgSchema.parse(commandArg);
+  return {
+    command
+  };
+};
+const main = async (args) => {
+  try {
+    const { command } = parseReleaseArgs(args);
+    if (command === "create") {
+      const release = await ReleaseCommands.createRelease();
+      if (!release) {
+        return 0;
+      }
+      if (process.env.GITHUB_ACTIONS === "true") {
+        ActionsCore.setOutput("version", release.version);
+      }
+    } else if (command === "extract-changelog") {
+      const changelog = await ReleaseCommands.extractChangelog();
+      if (process.env.GITHUB_ACTIONS === "true") {
+        ActionsCore.setOutput("changelog", changelog.body);
+      } else {
+        console.log(changelog.body);
+      }
+    }
+    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 command name");
+        return 1;
+      }
+    }
+    if (error instanceof Error) {
+      console.error(error.message);
+      return 1;
+    }
+    console.error(error);
+    return 1;
+  }
+};
+runMain(main);

package/dist/scripts/update-node-versions/main.js

@@ -0,0 +1,162 @@
+import * as ActionsCore from "@actions/core";
+import FileSystem from "fs/promises";
+import SemVer from "semver";
+import { z } from "zod";
+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 urlValue = urlString.includes(":") ? urlString : `https://${urlString}`;
+  const url = new URL(urlValue);
+  const scheme = url.protocol.slice(0, -1);
+  if (isGitProviderName(scheme)) {
+    const [owner, repositoryName] = url.pathname.split("/");
+    if (!owner || !repositoryName) {
+      throw new ParseGitRepositoryError("Unknown owner or repositoryName");
+    }
+    return {
+      origin: gitProviderOrigins[scheme],
+      owner,
+      repositoryName
+    };
+  }
+  if (scheme === "https") {
+    const [, owner, repositoryName] = url.pathname.split("/");
+    if (!owner || !repositoryName) {
+      throw new ParseGitRepositoryError("Unknown owner or repositoryName");
+    }
+    return {
+      origin: url.origin,
+      owner,
+      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
+};
+const runMain = (main2) => {
+  main2(process.argv.slice(2)).then((exitCode) => {
+    process.exit(exitCode);
+  }).catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+};
+const nodeReleasesUrl = "https://nodejs.org/dist/index.json";
+const nodeReleaseSchema = z.object({
+  version: z.string(),
+  // 'v20.5.1',
+  date: z.string(),
+  // '2023-08-09',
+  files: z.array(z.string()),
+  npm: z.ostring(),
+  // '9.8.0',
+  v8: z.string(),
+  // '11.3.244.8',
+  uv: z.ostring(),
+  // '1.46.0',
+  zlib: z.ostring(),
+  // '1.2.13.1-motley',
+  openssl: z.ostring(),
+  // '3.0.10+quic',
+  modules: z.ostring(),
+  // '115',
+  lts: z.union([z.boolean(), z.string()]),
+  // false, 'Argon',
+  security: z.boolean()
+});
+const nodeReleasesSchema = z.array(nodeReleaseSchema);
+const fetchNodeReleases = async () => {
+  const response = await fetch(nodeReleasesUrl);
+  const data = await response.json();
+  return nodeReleasesSchema.parse(data);
+};
+const fetchLatestNodeRelease = async () => {
+  const [latestRelease] = await fetchNodeReleases();
+  return latestRelease;
+};
+const NodeJsCommands = {
+  fetchLatestNodeRelease,
+  fetchNodeReleases
+};
+const updateNvmrc = (version) => FileSystem.writeFile(".nvmrc", `v${version}
+`);
+const updatePackageJson = async (version) => {
+  var _a;
+  const packageJson = await CoreCommands.readPackageJson();
+  if (!packageJson.engines) {
+    return;
+  }
+  const nodeVersion = packageJson.engines.node;
+  if (!nodeVersion || nodeVersion === version) {
+    return;
+  }
+  const coerceNodeVersion = (_a = SemVer.coerce(nodeVersion)) == null ? void 0 : _a.version;
+  if (!coerceNodeVersion) {
+    return;
+  }
+  packageJson.engines.node = nodeVersion.replace(coerceNodeVersion, version);
+  const nextContent = JSON.stringify(packageJson, null, 2) + "\n";
+  return FileSystem.writeFile("package.json", nextContent);
+};
+const main = async () => {
+  try {
+    const nodeRelease = await NodeJsCommands.fetchLatestNodeRelease();
+    const nodeVersion = nodeRelease == null ? void 0 : nodeRelease.version;
+    const versionNumber = (nodeVersion == null ? void 0 : nodeVersion.startsWith("v")) ? nodeVersion.slice(1) : nodeVersion;
+    if (!versionNumber) {
+      console.error("Error: Unknown latest Node.js version number");
+      return 1;
+    }
+    console.info(`Info: Trying to update Node.js versions to ${versionNumber}`);
+    await updateNvmrc(versionNumber);
+    await updatePackageJson(versionNumber);
+    console.info("Info: Update successful");
+    if (process.env.GITHUB_ACTIONS === "true") {
+      ActionsCore.setOutput("version", versionNumber);
+    }
+    return 0;
+  } catch (error) {
+    console.log(JSON.stringify(error, null, 2));
+    return 1;
+  }
+};
+runMain(main);

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@cluerise/tools",
+  "version": "3.0.0",
+  "description": "Tools for maintaining TypeScript projects.",
+  "author": "Branislav Holý <brano@holy.am>",
+  "repository": "github:cluerise/tools",
+  "bugs": {
+    "url": "https://github.com/cluerise/tools/issues"
+  },
+  "homepage": "https://github.com/cluerise/tools#readme",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "cluerise-tools": "./dist/bin/cluerise-tools.sh"
+  },
+  "files": [
+    "./dist/"
+  ],
+  "dependencies": {
+    "@actions/core": "1.10.1",
+    "@commitlint/cli": "19.3.0",
+    "@commitlint/load": "19.2.0",
+    "@commitlint/types": "19.0.3",
+    "@html-eslint/eslint-plugin": "0.24.1",
+    "@html-eslint/parser": "0.24.1",
+    "@typescript-eslint/eslint-plugin": "7.8.0",
+    "@typescript-eslint/parser": "7.8.0",
+    "conventional-changelog-conventionalcommits": "7.0.2",
+    "eslint": "8.57.0",
+    "eslint-config-prettier": "9.1.0",
+    "eslint-plugin-import": "2.29.1",
+    "eslint-plugin-json": "3.1.0",
+    "eslint-plugin-markdown": "5.0.0",
+    "eslint-plugin-prettier": "5.1.3",
+    "eslint-plugin-simple-import-sort": "12.1.0",
+    "eslint-plugin-yml": "1.14.0",
+    "glob": "10.3.14",
+    "lint-staged": "15.2.2",
+    "prettier": "3.2.5",
+    "semantic-release": "23.0.8",
+    "semver": "7.6.2",
+    "smol-toml": "1.1.4",
+    "zod": "3.23.8"
+  }
+}