better-commits 1.23.2 → 1.23.3

package/dist/chunk-H5CLUQIL.js

@@ -0,0 +1,313 @@
+import {
+  BRANCH_STATE_ENTRIES,
+  COMMIT_STATE_ENTRIES,
+  CUSTOM_SCOPE_KEY,
+  flags
+} from "./chunk-GAAS3VS3.js";
+
+// src/utils/no-interactive-validation.ts
+import * as v from "valibot";
+
+// src/utils/commit-title-size.ts
+function get_commit_title_size(val, options) {
+  const commit_scope_size = val.scope ? val.scope.length + 2 : 0;
+  const commit_type_size = val.type?.length ?? 0;
+  const commit_ticket_size = options.include_ticket ? val.ticket?.length ?? 0 : 0;
+  const title_size = val.title?.length ?? 0;
+  return commit_scope_size + commit_type_size + commit_ticket_size + title_size;
+}
+
+// src/utils/no-interactive-validation.ts
+function format_allowed_values(values) {
+  const printable_values = values.map(
+    (value) => value === "" ? '"" (none)' : `"${value}"`
+  );
+  return printable_values.join(", ");
+}
+function create_strict_commit_state(config) {
+  const type_values = config.commit_type.options.map((option) => option.value);
+  const scope_values = config.commit_scope.options.map(
+    (option) => option.value
+  );
+  return v.pipe(
+    v.object(COMMIT_STATE_ENTRIES),
+    v.rawCheck(({ dataset, addIssue }) => {
+      if (!dataset.typed)
+        return;
+      const received = dataset.value.type ? `"${dataset.value.type}"` : "(empty)";
+      if (dataset.value.type && !type_values.includes(dataset.value.type)) {
+        addIssue({
+          message: `Invalid --type ${received}. Valid types: ${format_allowed_values(type_values)}.`
+        });
+      }
+    }),
+    v.rawCheck(({ dataset, addIssue }) => {
+      if (!dataset.typed)
+        return;
+      const received = dataset.value.scope ? `"${dataset.value.scope}"` : "(empty)";
+      if (dataset.value.scope && !config.commit_scope.custom_scope && !scope_values.includes(dataset.value.scope)) {
+        addIssue({
+          message: `Invalid --scope ${received}. Valid scopes: ${format_allowed_values(scope_values)}.`
+        });
+      }
+    }),
+    v.rawCheck(({ dataset, addIssue }) => {
+      if (!dataset.typed || dataset.value.title.trim())
+        return;
+      addIssue({
+        message: "Missing --title. Provide a non-empty commit title."
+      });
+    }),
+    v.rawCheck(({ dataset, addIssue }) => {
+      if (!dataset.typed)
+        return;
+      const size = get_commit_title_size(dataset.value, {
+        include_ticket: config.check_ticket.add_to_title
+      });
+      if (size > config.commit_title.max_size) {
+        addIssue({
+          message: `Title exceeds max width. Current size is ${size}, max is ${config.commit_title.max_size} (includes type, scope, and ticket when enabled).`
+        });
+      }
+    }),
+    v.rawCheck(({ dataset, addIssue }) => {
+      if (dataset.typed && config.commit_body.required && !dataset.value.body.trim()) {
+        addIssue({
+          message: "Missing --body. commit_body.required is enabled in config."
+        });
+      }
+    }),
+    v.rawCheck(({ dataset, addIssue }) => {
+      if (dataset.typed && dataset.value.closes && !dataset.value.ticket) {
+        addIssue({
+          message: 'Invalid footer values: --closes requires --ticket (for example: --ticket "ABC-123").'
+        });
+      }
+    }),
+    v.rawCheck(({ dataset, addIssue }) => {
+      if (dataset.typed && dataset.value.breaking_body && !dataset.value.breaking_title) {
+        addIssue({
+          message: "Invalid breaking change values: --breaking-body requires --breaking-title."
+        });
+      }
+    }),
+    v.rawCheck(({ dataset, addIssue }) => {
+      if (dataset.typed && dataset.value.deprecates_body && !dataset.value.deprecates_title) {
+        addIssue({
+          message: "Invalid deprecation values: --deprecates-body requires --deprecates-title."
+        });
+      }
+    })
+  );
+}
+function create_strict_branch_state(config) {
+  const type_values = config.commit_type.options.map((option) => option.value);
+  const scope_values = config.commit_scope.options.map(
+    (option) => option.value
+  );
+  return v.pipe(
+    v.object(BRANCH_STATE_ENTRIES),
+    v.rawCheck(({ dataset, addIssue }) => {
+      if (!dataset.typed)
+        return;
+      const received = dataset.value.type ? `"${dataset.value.type}"` : "(empty)";
+      if (dataset.value.type && !type_values.includes(dataset.value.type)) {
+        addIssue({
+          message: `Invalid --type ${received}. Valid types: ${format_allowed_values(type_values)}.`
+        });
+      }
+    }),
+    v.rawCheck(({ dataset, addIssue }) => {
+      if (!dataset.typed)
+        return;
+      const received = dataset.value.scope ? `"${dataset.value.scope}"` : "(empty)";
+      if (dataset.value.scope && !config.commit_scope.custom_scope && !scope_values.includes(dataset.value.scope)) {
+        addIssue({
+          message: `Invalid --scope ${received}. Valid scopes: ${format_allowed_values(scope_values)}.`
+        });
+      }
+    }),
+    v.rawCheck(({ dataset, addIssue }) => {
+      if (!dataset.typed || dataset.value.description.trim())
+        return;
+      addIssue({
+        message: "Missing --description. Provide a non-empty branch description."
+      });
+    }),
+    v.rawCheck(({ dataset, addIssue }) => {
+      if (!dataset.typed)
+        return;
+      const description = dataset.value.description.trim();
+      if (description.length > config.branch_description.max_length) {
+        addIssue({
+          message: `Description exceeds max length. Current length is ${description.length}, max is ${config.branch_description.max_length}.`
+        });
+      }
+    }),
+    v.rawCheck(({ dataset, addIssue }) => {
+      if (dataset.typed && config.branch_user.required && !dataset.value.user.trim()) {
+        addIssue({
+          message: "Missing --user. branch_user.required is enabled in config."
+        });
+      }
+    }),
+    v.rawCheck(({ dataset, addIssue }) => {
+      if (dataset.typed && config.branch_ticket.required && !dataset.value.ticket.trim()) {
+        addIssue({
+          message: "Missing --ticket. branch_ticket.required is enabled in config."
+        });
+      }
+    }),
+    v.rawCheck(({ dataset, addIssue }) => {
+      if (dataset.typed && config.branch_version.required && !dataset.value.version.trim()) {
+        addIssue({
+          message: "Missing --branch-version. branch_version.required is enabled in config."
+        });
+      }
+    })
+  );
+}
+
+// src/utils/infer.ts
+import { execSync } from "child_process";
+var REGEX_SLASH_TAG = /\/(\w+-\d+)/;
+var REGEX_START_TAG = /^(\w+-\d+)/;
+var REGEX_START_UND = /^([A-Z]+-[\[a-zA-Z\]\d]+)_/;
+var REGEX_SLASH_UND = /\/([A-Z]+-[\[a-zA-Z\]\d]+)_/;
+var REGEX_SLASH_NUM = /\/(\d+)/;
+var REGEX_START_NUM = /^(\d+)/;
+function infer_not_interactive(config) {
+  if (flags.interactive)
+    return;
+  let inferred_state = { ticket: "", type: "", scope: "" };
+  if (config.check_ticket.infer_ticket) {
+    const inferred_ticket = infer_ticket_from_git(
+      {
+        append_hashtag: config.check_ticket.append_hashtag,
+        prepend_hashtag: config.check_ticket.prepend_hashtag
+      },
+      flags.git_args
+    );
+    inferred_state.ticket = inferred_ticket;
+  }
+  const inferred_type = infer_type_from_git(
+    config.commit_type.options,
+    flags.git_args
+  );
+  inferred_state.type = inferred_type;
+  if (config.commit_scope.enable && config.commit_scope.infer_scope_from_branch) {
+    const inferred_scope = infer_scope_from_git(
+      config.commit_scope.options,
+      flags.git_args
+    );
+    inferred_state.scope = inferred_scope;
+  }
+  return inferred_state;
+}
+function infer_type_from_git(options, git_args) {
+  const branch = get_current_branch(git_args);
+  if (!branch)
+    return "";
+  return infer_type_from_branch(
+    branch,
+    options.map((option) => option.value)
+  );
+}
+function infer_ticket_from_git(options, git_args) {
+  const branch = get_current_branch(git_args);
+  if (!branch)
+    return "";
+  return infer_ticket_from_branch(branch, options);
+}
+function infer_scope_from_git(options, git_args) {
+  const branch = get_current_branch(git_args);
+  if (!branch)
+    return "";
+  return infer_scope_from_branch(branch, options);
+}
+function infer_ticket_from_branch(branch, options) {
+  const found = [
+    branch.match(REGEX_START_UND),
+    branch.match(REGEX_SLASH_UND),
+    branch.match(REGEX_SLASH_TAG),
+    branch.match(REGEX_SLASH_NUM),
+    branch.match(REGEX_START_TAG),
+    branch.match(REGEX_START_NUM)
+  ].filter((value) => value != null).map((value) => value && value.length >= 2 ? value[1] : "");
+  if (!found.length || !found[0])
+    return "";
+  return options.append_hashtag || options.prepend_hashtag === "Always" ? `#${found[0]}` : found[0];
+}
+function infer_type_from_branch(branch, types) {
+  const found = types.find((type) => {
+    const start_dash = new RegExp(`^${type}-`);
+    const between_dash = new RegExp(`-${type}-`);
+    const before_slash = new RegExp(`${type}/`);
+    const matches = [
+      branch.match(start_dash),
+      branch.match(between_dash),
+      branch.match(before_slash)
+    ].filter((value) => value != null);
+    return matches.length > 0;
+  });
+  return found ?? "";
+}
+function escape_regexp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function infer_scope_from_branch(branch, options) {
+  const scopes = options.map((option) => option.value).filter((scope) => scope && scope !== CUSTOM_SCOPE_KEY).sort((a, b) => b.length - a.length);
+  const found = scopes.find((scope) => {
+    const standalone_scope = new RegExp(
+      `(?:^|[/_-])${escape_regexp(scope)}(?=$|[/_-])`
+    );
+    return standalone_scope.test(branch);
+  });
+  return found ?? "";
+}
+function get_current_branch(git_args) {
+  try {
+    return execSync(`git ${git_args} branch --show-current`, {
+      stdio: "pipe"
+    }).toString().trim();
+  } catch {
+    return "";
+  }
+}
+
+// src/utils/messages.ts
+import color from "picocolors";
+function cache_message(message) {
+  return `${message} ${color.dim("\xB7 restored from cache")}`;
+}
+function inferred_message(message) {
+  return `${message} ${color.dim("\xB7 inferred from branch")}`;
+}
+function optional_message(message) {
+  return `${message} ${color.dim("\xB7 optional")}`;
+}
+function space_to_select_message(message) {
+  return `${message} ${color.dim("\xB7 <space> to select")}`;
+}
+function a_for_all_message(message) {
+  return `${message} ${color.dim("\xB7 <space> to select \xB7 <a> to select all")}`;
+}
+function dry_run_message(message) {
+  return `${message} ${color.dim("\xB7 dry run - changes will not be committed")}`;
+}
+
+export {
+  get_commit_title_size,
+  create_strict_commit_state,
+  create_strict_branch_state,
+  infer_not_interactive,
+  infer_type_from_git,
+  infer_ticket_from_git,
+  infer_scope_from_git,
+  cache_message,
+  inferred_message,
+  optional_message,
+  space_to_select_message,
+  a_for_all_message,
+  dry_run_message
+};