@storm-software/git-tools 2.113.17 → 2.113.19

package/bin/git.js

@@ -9,11 +9,8 @@ import chalkTemplate from 'chalk-template';
 import fs, { readFile as readFile$1, writeFile } from 'node:fs/promises';
 import { existsSync } from 'fs';
 import { readFile } from 'fs/promises';
-import childProcess, { execSync, spawnSync } from 'node:child_process';
-import * as ensure from '@commitlint/ensure';
-import { minLength, maxLength, case as _case, maxLineLength } from '@commitlint/ensure';
-import message9 from '@commitlint/message';
-import toLines2 from '@commitlint/to-lines';
+import childProcess, { execSync } from 'node:child_process';
+import defaultRules from '@commitlint/rules';
 import 'stream';
 import util from 'util';
 import { readCachedProjectGraph, createProjectGraphAsync as createProjectGraphAsync$1, readProjectsConfigurationFromProjectGraph as readProjectsConfigurationFromProjectGraph$1 } from 'nx/src/project-graph/project-graph';
@@ -329,516 +326,6 @@ var DEFAULT_COMMITLINT_CONFIG = {
     issuePrefixes: ["#"]
   }
 };
-var negated = (when) => when === "never";
-var bodyCase = (parsed, when = "always", value = []) => {
-  const { body } = parsed;
-  if (!body) {
-    return [true];
-  }
-  const checks = (Array.isArray(value) ? value : [value]).map((check) => {
-    if (typeof check === "string") {
-      return {
-        when: "always",
-        case: check
-      };
-    }
-    return check;
-  });
-  const result = checks.some((check) => {
-    const r = _case(body, check.case);
-    return negated(check.when) ? !r : r;
-  });
-  const list = checks.map((c) => c.case).join(", ");
-  return [
-    negated(when) ? !result : result,
-    message9([`body must`, negated(when) ? `not` : null, `be ${list}`])
-  ];
-};
-var bodyEmpty = (parsed, when = "always") => {
-  const negated6 = when === "never";
-  const notEmpty6 = ensure.notEmpty(parsed.body || "");
-  return [
-    negated6 ? notEmpty6 : !notEmpty6,
-    message9(["body", negated6 ? "may not" : "must", "be empty"])
-  ];
-};
-var bodyFullStop = (parsed, when = "always", value = ".") => {
-  const input2 = parsed.body;
-  if (!input2) {
-    return [true];
-  }
-  const negated6 = when === "never";
-  const hasStop = input2[input2.length - 1] === value;
-  return [
-    negated6 ? !hasStop : hasStop,
-    message9(["body", negated6 ? "may not" : "must", "end with full stop"])
-  ];
-};
-var bodyLeadingBlank = (parsed, when) => {
-  if (!parsed.body) {
-    return [true];
-  }
-  const negated6 = when === "never";
-  const [leading] = toLines2(parsed.raw).slice(1);
-  const succeeds = leading === "";
-  return [
-    negated6 ? !succeeds : succeeds,
-    message9(["body", negated6 ? "may not" : "must", "have leading blank line"])
-  ];
-};
-var bodyMaxLength = (parsed, _when = void 0, value = 0) => {
-  const input2 = parsed.body;
-  if (!input2) {
-    return [true];
-  }
-  return [
-    maxLength(input2, value),
-    `body must not be longer than ${value} characters`
-  ];
-};
-var bodyMaxLineLength = (parsed, _when = void 0, value = 0) => {
-  const input2 = parsed.body;
-  if (!input2) {
-    return [true];
-  }
-  return [
-    maxLineLength(input2, value),
-    `body's lines must not be longer than ${value} characters`
-  ];
-};
-var bodyMinLength = (parsed, _when = void 0, value = 0) => {
-  if (!parsed.body) {
-    return [true];
-  }
-  return [
-    minLength(parsed.body, value),
-    `body must not be shorter than ${value} characters`
-  ];
-};
-var footerEmpty = (parsed, when = "always") => {
-  const negated6 = when === "never";
-  const notEmpty6 = ensure.notEmpty(parsed.footer || "");
-  return [
-    negated6 ? notEmpty6 : !notEmpty6,
-    message9(["footer", negated6 ? "may not" : "must", "be empty"])
-  ];
-};
-var footerLeadingBlank = (parsed, when = "always") => {
-  if (!parsed.footer) {
-    return [true];
-  }
-  const negated6 = when === "never";
-  const rawLines = toLines2(parsed.raw);
-  const footerLines = toLines2(parsed.footer);
-  const footerOffset = rawLines.indexOf(footerLines[0]);
-  const [leading] = rawLines.slice(footerOffset - 1);
-  const succeeds = leading === "";
-  return [
-    negated6 ? !succeeds : succeeds,
-    message9([
-      "footer",
-      negated6 ? "may not" : "must",
-      "have leading blank line"
-    ])
-  ];
-};
-var footerMaxLength = (parsed, _when = void 0, value = 0) => {
-  const input2 = parsed.footer;
-  if (!input2) {
-    return [true];
-  }
-  return [
-    maxLength(input2, value),
-    `footer must not be longer than ${value} characters`
-  ];
-};
-var footerMaxLineLength = (parsed, _when = void 0, value = 0) => {
-  const input2 = parsed.footer;
-  if (!input2) {
-    return [true];
-  }
-  return [
-    maxLineLength(input2, value),
-    `footer's lines must not be longer than ${value} characters`
-  ];
-};
-var footerMinLength = (parsed, _when = void 0, value = 0) => {
-  if (!parsed.footer) {
-    return [true];
-  }
-  return [
-    minLength(parsed.footer, value),
-    `footer must not be shorter than ${value} characters`
-  ];
-};
-var negated2 = (when) => when === "never";
-var headerCase = (parsed, when = "always", value = []) => {
-  const { header } = parsed;
-  if (typeof header !== "string" || !header.match(/^[a-z]/i)) {
-    return [true];
-  }
-  const checks = (Array.isArray(value) ? value : [value]).map((check) => {
-    if (typeof check === "string") {
-      return {
-        when: "always",
-        case: check
-      };
-    }
-    return check;
-  });
-  const result = checks.some((check) => {
-    const r = _case(header, check.case);
-    return negated2(check.when) ? !r : r;
-  });
-  const list = checks.map((c) => c.case).join(", ");
-  return [
-    negated2(when) ? !result : result,
-    message9([`header must`, negated2(when) ? `not` : null, `be ${list}`])
-  ];
-};
-var headerFullStop = (parsed, when = "always", value = ".") => {
-  const { header } = parsed;
-  const negated6 = when === "never";
-  const hasStop = header?.[header.length - 1] === value;
-  return [
-    negated6 ? !hasStop : hasStop,
-    message9(["header", negated6 ? "may not" : "must", "end with full stop"])
-  ];
-};
-var headerMaxLength = (parsed, _when = void 0, value = 0) => {
-  return [
-    maxLength(parsed.header, value),
-    `header must not be longer than ${value} characters, current length is ${parsed.header?.length}`
-  ];
-};
-var headerMinLength = (parsed, _when = void 0, value = 0) => {
-  return [
-    minLength(parsed.header, value),
-    `header must not be shorter than ${value} characters, current length is ${parsed.header?.length}`
-  ];
-};
-var headerTrim = (parsed) => {
-  const { header } = parsed;
-  if (!header)
-    return [true];
-  const startsWithWhiteSpace = header.length > header.trimStart().length;
-  const endsWithWhiteSpace = header.length > header.trimEnd().length;
-  if (startsWithWhiteSpace && endsWithWhiteSpace)
-    return [false, message9(["header", "must not be surrounded by whitespace"])];
-  if (startsWithWhiteSpace)
-    return [false, message9(["header", "must not start with whitespace"])];
-  if (endsWithWhiteSpace)
-    return [false, message9(["header", "must not end with whitespace"])];
-  return [true];
-};
-var referencesEmpty = (parsed, when = "never") => {
-  const negated6 = when === "always";
-  const notEmpty6 = parsed.references.length > 0;
-  return [
-    negated6 ? !notEmpty6 : notEmpty6,
-    message9(["references", negated6 ? "must" : "may not", "be empty"])
-  ];
-};
-var negated3 = (when) => when === "never";
-var scopeCase = (parsed, when = "always", value = []) => {
-  const { scope } = parsed;
-  if (!scope) {
-    return [true];
-  }
-  const checks = (Array.isArray(value) ? value : [value]).map((check) => {
-    if (typeof check === "string") {
-      return {
-        when: "always",
-        case: check
-      };
-    }
-    return check;
-  });
-  const delimiters = /\/|\\|, ?/g;
-  const scopeSegments = scope.split(delimiters);
-  const result = checks.some((check) => {
-    const r = scopeSegments.every((segment) => delimiters.test(segment) || _case(segment, check.case));
-    return negated3(check.when) ? !r : r;
-  });
-  const list = checks.map((c) => c.case).join(", ");
-  return [
-    negated3(when) ? !result : result,
-    message9([`scope must`, negated3(when) ? `not` : null, `be ${list}`])
-  ];
-};
-var scopeEmpty = (parsed, when = "never") => {
-  const negated6 = when === "always";
-  const notEmpty6 = ensure.notEmpty(parsed.scope || "");
-  return [
-    negated6 ? !notEmpty6 : notEmpty6,
-    message9(["scope", negated6 ? "must" : "may not", "be empty"])
-  ];
-};
-var scopeEnum = ({ scope }, when = "always", value = []) => {
-  if (!scope || !value.length) {
-    return [true, ""];
-  }
-  const delimiters = /\/|\\|, ?/g;
-  const messageScopes = scope.split(delimiters);
-  const errorMessage = ["scope must", `be one of [${value.join(", ")}]`];
-  const isScopeInEnum = (scope2) => ensure.enum(scope2, value);
-  let isValid;
-  if (when === "never") {
-    isValid = !messageScopes.some(isScopeInEnum) && !isScopeInEnum(scope);
-    errorMessage.splice(1, 0, "not");
-  } else {
-    isValid = messageScopes.every(isScopeInEnum) || isScopeInEnum(scope);
-  }
-  return [isValid, message9(errorMessage)];
-};
-var scopeMaxLength = (parsed, _when = void 0, value = 0) => {
-  const input2 = parsed.scope;
-  if (!input2) {
-    return [true];
-  }
-  return [
-    maxLength(input2, value),
-    `scope must not be longer than ${value} characters`
-  ];
-};
-var scopeMinLength = (parsed, _when = void 0, value = 0) => {
-  const input2 = parsed.scope;
-  if (!input2) {
-    return [true];
-  }
-  return [
-    minLength(input2, value),
-    `scope must not be shorter than ${value} characters`
-  ];
-};
-var signedOffBy = (parsed, when = "always", value = "") => {
-  const lines = toLines2(parsed.raw).filter((ln) => (
-    // skip comments
-    !ln.startsWith("#") && // ignore empty lines
-    Boolean(ln)
-  ));
-  const last = lines[lines.length - 1];
-  const negated6 = when === "never";
-  const hasSignedOffBy = (
-    // empty commit message
-    last ? last.startsWith(value) : false
-  );
-  return [
-    negated6 ? !hasSignedOffBy : hasSignedOffBy,
-    message9(["message", negated6 ? "must not" : "must", "be signed off"])
-  ];
-};
-var startsWithLetterRegex = /^[\p{Ll}\p{Lu}\p{Lt}]/iu;
-var negated4 = (when) => when === "never";
-var subjectCase = (parsed, when = "always", value = []) => {
-  const { subject } = parsed;
-  if (typeof subject !== "string" || !subject.match(startsWithLetterRegex)) {
-    return [true];
-  }
-  const checks = (Array.isArray(value) ? value : [value]).map((check) => {
-    if (typeof check === "string") {
-      return {
-        when: "always",
-        case: check
-      };
-    }
-    return check;
-  });
-  const result = checks.some((check) => {
-    const r = _case(subject, check.case);
-    return negated4(check.when) ? !r : r;
-  });
-  const list = checks.map((c) => c.case).join(", ");
-  return [
-    negated4(when) ? !result : result,
-    message9([`subject must`, negated4(when) ? `not` : null, `be ${list}`])
-  ];
-};
-var subjectEmpty = (parsed, when = "always") => {
-  const negated6 = when === "never";
-  const notEmpty6 = ensure.notEmpty(parsed.subject || "");
-  return [
-    negated6 ? notEmpty6 : !notEmpty6,
-    message9(["subject", negated6 ? "may not" : "must", "be empty"])
-  ];
-};
-var subjectFullStop = (parsed, when = "always", value = ".") => {
-  const colonIndex = parsed.header?.indexOf(":") || 0;
-  if (colonIndex > 0 && colonIndex === parsed.header.length - 1) {
-    return [true];
-  }
-  const input2 = parsed.header;
-  const negated6 = when === "never";
-  let hasStop = input2?.[input2.length - 1] === value;
-  if (input2?.slice(-3) === "...") {
-    hasStop = false;
-  }
-  return [
-    negated6 ? !hasStop : hasStop,
-    message9(["subject", negated6 ? "may not" : "must", "end with full stop"])
-  ];
-};
-var subjectMaxLength = (parsed, _when = void 0, value = 0) => {
-  const input2 = parsed.subject;
-  if (!input2) {
-    return [true];
-  }
-  return [
-    maxLength(input2, value),
-    `subject must not be longer than ${value} characters`
-  ];
-};
-var subjectMinLength = (parsed, _when = void 0, value = 0) => {
-  const input2 = parsed.subject;
-  if (!input2) {
-    return [true];
-  }
-  return [
-    minLength(input2, value),
-    `subject must not be shorter than ${value} characters`
-  ];
-};
-var subjectExclamationMark = (parsed, when = "always") => {
-  const input2 = parsed.header;
-  if (!input2) {
-    return [true, ""];
-  }
-  const negated6 = when === "never";
-  const hasExclamationMark = /!:/.test(input2);
-  return [
-    negated6 ? !hasExclamationMark : hasExclamationMark,
-    message9([
-      "subject",
-      negated6 ? "must not" : "must",
-      "have an exclamation mark in the subject to identify a breaking change"
-    ])
-  ];
-};
-var trailerExists = (parsed, when = "always", value = "") => {
-  const trailers = spawnSync("git", ["interpret-trailers", "--parse"], {
-    input: parsed.raw || ""
-  }).stdout;
-  const matches = toLines2(trailers.toString()).filter((ln) => ln.startsWith(value)).length;
-  const negated6 = when === "never";
-  const hasTrailer = matches > 0;
-  return [
-    negated6 ? !hasTrailer : hasTrailer,
-    message9([
-      "message",
-      negated6 ? "must not" : "must",
-      "have `" + value + "` trailer"
-    ])
-  ];
-};
-var negated5 = (when) => when === "never";
-var typeCase = (parsed, when = "always", value = []) => {
-  const { type } = parsed;
-  if (!type) {
-    return [true];
-  }
-  const checks = (Array.isArray(value) ? value : [value]).map((check) => {
-    if (typeof check === "string") {
-      return {
-        when: "always",
-        case: check
-      };
-    }
-    return check;
-  });
-  const result = checks.some((check) => {
-    const r = _case(type, check.case);
-    return negated5(check.when) ? !r : r;
-  });
-  const list = checks.map((c) => c.case).join(", ");
-  return [
-    negated5(when) ? !result : result,
-    message9([`type must`, negated5(when) ? `not` : null, `be ${list}`])
-  ];
-};
-var typeEmpty = (parsed, when = "always") => {
-  const negated6 = when === "never";
-  const notEmpty6 = ensure.notEmpty(parsed.type || "");
-  return [
-    negated6 ? notEmpty6 : !notEmpty6,
-    message9(["type", negated6 ? "may not" : "must", "be empty"])
-  ];
-};
-var typeEnum = (parsed, when = "always", value = []) => {
-  const { type: input2 } = parsed;
-  if (!input2) {
-    return [true];
-  }
-  const negated6 = when === "never";
-  const result = ensure.enum(input2, value);
-  return [
-    negated6 ? !result : result,
-    message9([
-      `type must`,
-      negated6 ? `not` : null,
-      `be one of [${value.join(", ")}]`
-    ])
-  ];
-};
-var typeMaxLength = (parsed, _when = void 0, value = 0) => {
-  const input2 = parsed.type;
-  if (!input2) {
-    return [true];
-  }
-  return [
-    maxLength(input2, value),
-    `type must not be longer than ${value} characters`
-  ];
-};
-var typeMinLength = (parsed, _when = void 0, value = 0) => {
-  const input2 = parsed.type;
-  if (!input2) {
-    return [true];
-  }
-  return [
-    minLength(input2, value),
-    `type must not be shorter than ${value} characters`
-  ];
-};
-
-// ../../node_modules/.pnpm/@commitlint+rules@19.8.1/node_modules/@commitlint/rules/lib/index.js
-var lib_default = {
-  "body-case": bodyCase,
-  "body-empty": bodyEmpty,
-  "body-full-stop": bodyFullStop,
-  "body-leading-blank": bodyLeadingBlank,
-  "body-max-length": bodyMaxLength,
-  "body-max-line-length": bodyMaxLineLength,
-  "body-min-length": bodyMinLength,
-  "footer-empty": footerEmpty,
-  "footer-leading-blank": footerLeadingBlank,
-  "footer-max-length": footerMaxLength,
-  "footer-max-line-length": footerMaxLineLength,
-  "footer-min-length": footerMinLength,
-  "header-case": headerCase,
-  "header-full-stop": headerFullStop,
-  "header-max-length": headerMaxLength,
-  "header-min-length": headerMinLength,
-  "header-trim": headerTrim,
-  "references-empty": referencesEmpty,
-  "scope-case": scopeCase,
-  "scope-empty": scopeEmpty,
-  "scope-enum": scopeEnum,
-  "scope-max-length": scopeMaxLength,
-  "scope-min-length": scopeMinLength,
-  "signed-off-by": signedOffBy,
-  "subject-case": subjectCase,
-  "subject-empty": subjectEmpty,
-  "subject-full-stop": subjectFullStop,
-  "subject-max-length": subjectMaxLength,
-  "subject-min-length": subjectMinLength,
-  "subject-exclamation-mark": subjectExclamationMark,
-  "trailer-exists": trailerExists,
-  "type-case": typeCase,
-  "type-empty": typeEmpty,
-  "type-enum": typeEnum,
-  "type-max-length": typeMaxLength,
-  "type-min-length": typeMinLength
-};
 
 // ../../node_modules/.pnpm/conventional-commits-parser@6.2.0/node_modules/conventional-commits-parser/dist/regex.js
 var nomatchRegex = /(?!.*)/;
@@ -1246,30 +733,30 @@ var buildCommitMessage = ({
   body,
   footer
 }) => {
-  let message23 = header;
-  message23 = body ? `${message23}
+  let message = header;
+  message = body ? `${message}
 
-${body}` : message23;
-  message23 = footer ? `${message23}
+${body}` : message;
+  message = footer ? `${message}
 
-${footer}` : message23;
-  return message23 || "";
+${footer}` : message;
+  return message || "";
 };
-async function lint(message23, rawRulesConfig, rawOpts) {
+async function lint(message, rawRulesConfig, rawOpts) {
   const rulesConfig = rawRulesConfig || {};
   const parser = new CommitParser(
     rawOpts?.parserOpts ?? DEFAULT_COMMITLINT_CONFIG.parserOpts
   );
-  const parsed = parser.parse(message23);
+  const parsed = parser.parse(message);
   if (parsed.header === null && parsed.body === null && parsed.footer === null) {
     return {
       valid: true,
       errors: [],
       warnings: [],
-      input: message23
+      input: message
     };
   }
-  const allRules = new Map(Object.entries(lib_default));
+  const allRules = new Map(Object.entries(defaultRules));
   const missing = Object.keys(rulesConfig).filter(
     (name) => typeof allRules.get(name) !== "function"
   );
@@ -1343,12 +830,12 @@ async function lint(message23, rawRulesConfig, rawOpts) {
       throw new Error(`Could not find rule implementation for ${name}`);
     }
     const executableRule = rule;
-    const [valid3, message24] = await executableRule(parsed, when, value);
+    const [valid3, message2] = await executableRule(parsed, when, value);
     return {
       level,
       valid: valid3,
       name,
-      message: message24
+      message: message2
     };
   });
   const results = (await Promise.all(pendingResults)).filter(
@@ -1397,14 +884,14 @@ function getScopeEnumUtil(context) {
 function getScopeEnum(context) {
   return getNxScopes(context);
 }
-function getRuleFromScopeEnum(scopeEnum2) {
-  if (!scopeEnum2?.filter(Boolean).length) {
+function getRuleFromScopeEnum(scopeEnum) {
+  if (!scopeEnum?.filter(Boolean).length) {
     throw new Error("No scopes found in the Storm workspace.");
   }
   return [
     2 /* Error */,
     "always",
-    scopeEnum2.filter(Boolean)
+    scopeEnum.filter(Boolean)
   ];
 }
 
@@ -1701,16 +1188,16 @@ var runCommit = async (commitizenFile = "@storm-software/git-tools/commit/config
 {#CCCCCC Please provide the requested details below...}
 `);
   state.answers = await askQuestions(state);
-  const message23 = formatCommitMessage(state);
+  const message = formatCommitMessage(state);
   const commitMsgFile = joinPaths(getGitDir(), "COMMIT_EDITMSG");
   console.log(chalkTemplate`
 {bold.#999999 ----------------------------------------}
 
-{bold.#FFFFFF Commit message} - {#DDDDDD ${message23}}
+{bold.#FFFFFF Commit message} - {#DDDDDD ${message}}
 {bold.#FFFFFF Git-Commit File} - {#DDDDDD ${commitMsgFile}}
 
     `);
-  await runCommitLint(config, { message: message23 });
+  await runCommitLint(config, { message });
   const commandItems = ["git", "commit", "-S"];
   commandItems.push(...["--file", commitMsgFile]);
   const command = shellescape(commandItems);
@@ -1719,9 +1206,9 @@ var runCommit = async (commitizenFile = "@storm-software/git-tools/commit/config
       `Skipping execution [dry-run]: ${command.replace(commitMsgFile, ".git/COMMIT_EDITMSG")}`,
       config
     );
-    writeDebug(`Message [dry-run]: ${message23}`, config);
+    writeDebug(`Message [dry-run]: ${message}`, config);
   } else {
-    await fs.writeFile(commitMsgFile, message23);
+    await fs.writeFile(commitMsgFile, message);
     run(config, command);
   }
 };
@@ -1739,11 +1226,11 @@ var askQuestions = async (state) => {
   return state.answers;
 };
 var askQuestion = (index, question) => {
-  const message23 = chalkTemplate`{bold ${index + 1}. ${question.title}} - ${question.description}
+  const message = chalkTemplate`{bold ${index + 1}. ${question.title}} - ${question.description}
 `;
   if (question.type === "select" && question.enum && Object.keys(question.enum).length > 1) {
     return select({
-      message: message23,
+      message,
       choices: Object.keys(question.enum).filter((key) => !question.enum?.[key]?.hidden).map((key) => ({
         name: question.enum?.[key]?.title || key,
         value: key,
@@ -1753,7 +1240,7 @@ var askQuestion = (index, question) => {
     });
   } else if (question.type === "confirm") {
     return confirm({
-      message: message23,
+      message,
       default: Boolean(question.defaultValue)
     });
   } else {
@@ -1770,7 +1257,7 @@ var askQuestion = (index, question) => {
       };
     }
     return input({
-      message: message23,
+      message,
       required: !!(question.minLength !== void 0 && question.minLength > 0),
       default: String(question.defaultValue || ""),
       validate
@@ -2821,7 +2308,7 @@ function parseChangelogMarkdown(contents) {
 }
 async function gitTag({
   tag,
-  message: message23,
+  message,
   additionalArgs,
   dryRun,
   verbose,
@@ -2835,7 +2322,7 @@ async function gitTag({
     "--sign",
     tag,
     "--message",
-    message23 || tag
+    message || tag
   ];
   if (additionalArgs) {
     if (Array.isArray(additionalArgs)) {
@@ -2870,8 +2357,8 @@ async function gitCommit({
 }) {
   logFn = logFn || console.log;
   const commandArgs = ["commit", "-S"];
-  for (const message23 of messages) {
-    commandArgs.push("--message", message23);
+  for (const message of messages) {
+    commandArgs.push("--message", message);
   }
   if (additionalArgs) {
     if (Array.isArray(additionalArgs)) {
@@ -4905,7 +4392,7 @@ Stacktrace: ${error.stack}` : ""}`,
 }
 async function commitLintAction({
   config,
-  message: message23,
+  message,
   file
 }) {
   try {
@@ -4915,7 +4402,7 @@ async function commitLintAction({
     );
     await runCommitLint(_config, {
       config,
-      message: message23,
+      message,
       file
     });
     writeSuccess(