@astra-kit/rp 0.0.0-stage → 0.10.0

package/src/terminal-ui.js

@@ -0,0 +1,548 @@
+/**
+ * Dependency-free terminal UI for release commands: colors, banner, rounded
+ * boxes, step headers, spinners and the interactive select prompt.
+ *
+ * Colors go through `util.styleText`, which drops ANSI codes automatically
+ * when stdout is not a TTY or `NO_COLOR` is set. Interactive prompts fall
+ * back to their default answer when stdin is not a TTY, so a command never
+ * hangs in a pipe.
+ *
+ * @module terminal-ui
+ */
+
+import { emitKeypressEvents } from "node:readline";
+import { stripVTControlCharacters, styleText } from "node:util";
+
+import {
+  ANSI_ESCAPE,
+  ANSI_SEQUENCE,
+  ANSI_TOKEN_PATTERN,
+  BOX_PADDING,
+  BOX_TONE,
+  FALLBACK_TERMINAL_WIDTH,
+  HANGING_MARKER_PATTERN,
+  ICON_GLYPH,
+  INTERRUPTED_EXIT_CODE,
+  MAX_BOX_WIDTH,
+  MAX_NUMBERED_OPTIONS,
+  MILLISECONDS_PER_SECOND,
+  NUMBER_KEY_PATTERN,
+  PROMPT_KEY,
+  ROW_LABEL_WIDTH,
+  SECONDS_PER_MINUTE,
+  SPINNER_FRAMES,
+  SPINNER_INTERVAL_MS,
+  TERMINAL_RIGHT_MARGIN,
+  VALUE_COLUMN_PATTERN,
+} from "./constants/terminal-ui.js";
+
+/**
+ * @typedef {Parameters<typeof styleText>[0]} TextFormat
+ * @typedef {{ label: string, hint?: string, description?: string, value: string }} SelectOption
+ */
+
+/** Time spent waiting for answers, excluded from the reported total. */
+let promptWaitMs = 0;
+
+/**
+ * Icons shared by status lines, colored once at import. They use Nerd Font
+ * glyphs, so the terminal needs a Nerd Font.
+ */
+export const ICON = {
+  success: styleText("green", ICON_GLYPH.success),
+  failure: styleText("red", ICON_GLYPH.failure),
+  warning: styleText("yellow", ICON_GLYPH.warning),
+  info: styleText("cyan", ICON_GLYPH.info),
+  pending: styleText("gray", ICON_GLYPH.pending),
+  arrow: styleText("magenta", ICON_GLYPH.arrow),
+  bullet: styleText("gray", ICON_GLYPH.bullet),
+  star: styleText("yellow", ICON_GLYPH.star),
+  rocket: ICON_GLYPH.rocket,
+};
+
+/**
+ * Returns how long the command has waited for the user's answers.
+ *
+ * @returns {number} Milliseconds spent with a prompt open.
+ */
+export function getPromptWaitMs() {
+  return promptWaitMs;
+}
+
+/**
+ * Measures the elapsed time since a start, without the time spent waiting for answers.
+ *
+ * @param {number} startedAt - `Date.now()` when the measured work started.
+ * @param {number} [promptWaitAtStart] - {@link getPromptWaitMs} at that moment.
+ * @returns {number} Active milliseconds.
+ */
+export function measureActiveMs(startedAt, promptWaitAtStart = 0) {
+  return Date.now() - startedAt - (promptWaitMs - promptWaitAtStart);
+}
+
+/**
+ * Moves the cursor up a number of lines.
+ *
+ * @param {number} lineCount - Lines to move.
+ * @returns {string} ANSI sequence, empty when there is nothing to move.
+ */
+function cursorUp(lineCount) {
+  return lineCount > 0 ? `${ANSI_ESCAPE}[${lineCount}A` : "";
+}
+
+/**
+ * Applies one or more `util.styleText` formats.
+ *
+ * @param {TextFormat} format - Format names such as `"bold"` or `["cyan", "bold"]`.
+ * @param {string} text - Text to style.
+ * @returns {string} Styled text (plain when colors are disabled).
+ */
+export function paint(format, text) {
+  return styleText(format, text);
+}
+
+/**
+ * Measures the visible width of a string, ignoring ANSI codes.
+ *
+ * @param {string} text - Possibly styled text.
+ * @returns {number} Visible column count.
+ */
+export function visibleWidth(text) {
+  return [...stripVTControlCharacters(text)].length;
+}
+
+/**
+ * Splits styled text into words (with their ANSI codes) and the spaces between them.
+ *
+ * @param {string} text - Possibly styled text.
+ * @returns {{ text: string, width: number, isSpace: boolean }[]} Segments in order.
+ */
+function splitStyledSegments(text) {
+  /** @type {{ text: string, width: number, isSpace: boolean }[]} */
+  const segments = [];
+
+  for (const token of text.match(ANSI_TOKEN_PATTERN) ?? []) {
+    const isEscape = token.startsWith(ANSI_ESCAPE);
+    const isSpace = !isEscape && token === " ";
+    const last = segments.at(-1);
+
+    // An escape after a space starts the next word so it is never dropped with a line-start space.
+    if (last && ((isEscape && !last.isSpace) || (!isEscape && last.isSpace === isSpace))) {
+      last.text += token;
+      last.width += isEscape ? 0 : 1;
+    } else {
+      segments.push({ text: token, width: isEscape ? 0 : 1, isSpace });
+    }
+  }
+
+  return segments;
+}
+
+/**
+ * Returns the ANSI sequences seen so far, so a continuation line reopens the active styles.
+ *
+ * @param {string} text - Styled text already emitted.
+ * @returns {string} Concatenated escape sequences.
+ */
+function collectEscapes(text) {
+  return (text.match(ANSI_TOKEN_PATTERN) ?? []).filter((token) => token.startsWith(ANSI_ESCAPE)).join("");
+}
+
+/**
+ * Word-wraps a styled line to a visible width without ever cutting it off:
+ * words move to the next line, continuation lines align after a leading
+ * marker (icon, arrow, bullet or `1.`), styles are closed at each break and
+ * reopened on the next line, and a word longer than the width is split.
+ *
+ * @param {string} text - Possibly styled line.
+ * @param {number} width - Maximum visible width.
+ * @returns {string[]} Lines that each fit in `width` columns.
+ */
+export function wrapStyledLine(text, width) {
+  if (visibleWidth(text) <= width) {
+    return [text];
+  }
+
+  // Continuation lines align with the value column of a row, or after a leading marker.
+  const plainText = stripVTControlCharacters(text);
+  const indentPrefix = VALUE_COLUMN_PATTERN.exec(plainText)?.[0] ?? HANGING_MARKER_PATTERN.exec(plainText)?.[0] ?? "";
+  const indentWidth = [...indentPrefix].length;
+  const hangingIndent = indentWidth < width / 2 ? " ".repeat(indentWidth) : "";
+  /** @type {string[]} */
+  const lines = [];
+  let current = "";
+  let currentWidth = 0;
+  let emitted = "";
+
+  const closeLine = () => {
+    const hasStyles = current !== stripVTControlCharacters(current);
+    lines.push(`${current.trimEnd()}${hasStyles ? ANSI_SEQUENCE.reset : ""}`);
+  };
+
+  const breakLine = () => {
+    closeLine();
+    emitted += current;
+    current = `${hangingIndent}${collectEscapes(emitted)}`;
+    currentWidth = hangingIndent.length;
+  };
+
+  for (const segment of splitStyledSegments(text)) {
+    const isLineStart = currentWidth === hangingIndent.length && lines.length > 0;
+
+    if (segment.isSpace) {
+      if (!isLineStart) {
+        current += segment.text;
+        currentWidth += segment.width;
+      }
+      continue;
+    }
+
+    // Move the word to the next line only when it fits there; a longer word is split right here.
+    const fitsOnFreshLine = hangingIndent.length + segment.width <= width;
+    if (currentWidth + segment.width > width && currentWidth > hangingIndent.length && fitsOnFreshLine) {
+      breakLine();
+    }
+
+    // A single word wider than the line is split across lines instead of truncated.
+    for (const token of segment.text.match(ANSI_TOKEN_PATTERN) ?? []) {
+      const isEscape = token.startsWith(ANSI_ESCAPE);
+
+      if (!isEscape && currentWidth >= width) {
+        breakLine();
+      }
+
+      current += token;
+      currentWidth += isEscape ? 0 : 1;
+    }
+  }
+
+  if (stripVTControlCharacters(current).trim()) {
+    closeLine();
+  }
+
+  return lines;
+}
+
+/**
+ * Returns the box width for the current terminal.
+ *
+ * @returns {number} Outer width in columns.
+ */
+export function resolveBoxWidth() {
+  const columns = process.stdout.columns || FALLBACK_TERMINAL_WIDTH;
+  return Math.min(columns - TERMINAL_RIGHT_MARGIN, MAX_BOX_WIDTH);
+}
+
+/**
+ * Renders a rounded box with an optional title in its top border. Long lines
+ * are word-wrapped, never truncated; a title that does not fit in the border
+ * moves inside the box as its first lines.
+ *
+ * @param {{ title?: string, lines: string[], tone?: TextFormat, width?: number }} options - Box content.
+ * @returns {string} Multi-line box.
+ */
+export function renderBox({ title, lines, tone = BOX_TONE.neutral, width = resolveBoxWidth() }) {
+  /** @param {string} text */
+  const border = (text) => paint(tone, text);
+  const innerWidth = width - 2;
+  const contentWidth = innerWidth - BOX_PADDING * 2;
+  const titleText = title ? ` ${paint("bold", title)} ` : "";
+  const titleFits = visibleWidth(titleText) + 1 <= innerWidth;
+  const borderTitle = titleFits ? titleText : "";
+  const topFill = Math.max(innerWidth - visibleWidth(borderTitle) - 1, 0);
+  const top = `${border("╭─")}${borderTitle}${border(`${"─".repeat(topFill)}╮`)}`;
+  const padding = " ".repeat(BOX_PADDING);
+  const contentLines = titleFits || !title ? lines : [paint("bold", title), "", ...lines];
+  const body = contentLines
+    .flatMap((line) => wrapStyledLine(line, contentWidth))
+    .map((line) => {
+      const fill = " ".repeat(Math.max(contentWidth - visibleWidth(line), 0));
+      return `${border("│")}${padding}${line}${fill}${padding}${border("│")}`;
+    });
+  const bottom = border(`╰${"─".repeat(innerWidth)}╯`);
+
+  return [top, ...body, bottom].join("\n");
+}
+
+/**
+ * Renders a label/value row aligned for status panels.
+ *
+ * @param {string} icon - Leading icon.
+ * @param {string} label - Left column.
+ * @param {string} value - Right column.
+ * @param {number} [labelWidth] - Width of the label column.
+ * @returns {string} Row.
+ */
+export function renderRow(icon, label, value, labelWidth = ROW_LABEL_WIDTH) {
+  // A label as wide as the column still keeps one space before its value.
+  return `${icon} ${paint("bold", label.padEnd(Math.max(labelWidth, label.length + 1)))}${value}`;
+}
+
+/**
+ * Renders the one-line header shown when a release command starts: an
+ * inverted `RELEASE` label, the project name, the published version aligned
+ * to the right and a rule underneath.
+ *
+ * @param {{ projectName: string, publishedLabel: string | null }} options - Header content.
+ * @returns {string} Header.
+ */
+export function renderBanner({ projectName, publishedLabel }) {
+  const width = resolveBoxWidth();
+  const left = `${paint(["inverse", "bold", "magenta"], " RELEASE ")}  ${paint("bold", projectName)}`;
+  const right = publishedLabel ? paint("gray", publishedLabel) : "";
+  const gap = " ".repeat(Math.max(width - visibleWidth(left) - visibleWidth(right), 2));
+
+  return ["", `${left}${gap}${right}`, paint("gray", "─".repeat(width)), ""].join("\n");
+}
+
+/**
+ * Renders the header that introduces each executed step: a blank line, the `━━ PASO N/M ━ title ━…`
+ * rule (only the step label in bold) and a blank line that separates it from the step output.
+ *
+ * @param {number} stepNumber - 1-based index.
+ * @param {number} stepCount - Total steps.
+ * @param {string} title - Step title, in regular weight.
+ * @returns {string} Header lines.
+ */
+export function renderStepHeader(stepNumber, stepCount, title) {
+  const label = paint(["bold", "magenta"], ` PASO ${stepNumber}/${stepCount} `);
+  const text = ` ${title} `;
+  const fill = Math.max(resolveBoxWidth() - visibleWidth(label) - visibleWidth(text) - 2, 2);
+
+  return ["", `${paint("magenta", "━━")}${label}${paint("magenta", "━")}${text}${paint("magenta", "━".repeat(fill))}`, ""].join("\n");
+}
+
+/**
+ * Writes a line to stdout.
+ *
+ * @param {string} [text] - Line content.
+ */
+export function print(text = "") {
+  process.stdout.write(`${text}\n`);
+}
+
+/**
+ * Formats a duration in a compact Spanish form.
+ *
+ * @param {number} milliseconds - Duration.
+ * @returns {string} Such as `3.2 s` or `4 min 05 s`.
+ */
+export function formatDuration(milliseconds) {
+  const totalSeconds = milliseconds / MILLISECONDS_PER_SECOND;
+
+  if (totalSeconds < SECONDS_PER_MINUTE) {
+    return `${totalSeconds.toFixed(1)} s`;
+  }
+
+  const minutes = Math.floor(totalSeconds / SECONDS_PER_MINUTE);
+  const seconds = Math.round(totalSeconds % SECONDS_PER_MINUTE);
+  return `${minutes} min ${String(seconds).padStart(2, "0")} s`;
+}
+
+/**
+ * Starts a spinner; on non-TTY outputs it prints the label once instead.
+ *
+ * @param {string} label - Initial label.
+ * @returns {{ update: (label: string) => void, succeed: (label?: string) => void, fail: (label?: string) => void }} Controls.
+ */
+export function startSpinner(label) {
+  const isInteractive = Boolean(process.stdout.isTTY);
+  const startedAt = Date.now();
+  let currentLabel = label;
+  let frameIndex = 0;
+  /** @type {ReturnType<typeof setInterval> | null} */
+  let timer = null;
+
+  const render = () => {
+    const frame = paint("magenta", SPINNER_FRAMES[frameIndex % SPINNER_FRAMES.length]);
+    process.stdout.write(`${ANSI_SEQUENCE.clearLine}${frame} ${currentLabel}`);
+    frameIndex += 1;
+  };
+
+  if (isInteractive) {
+    process.stdout.write(ANSI_SEQUENCE.hideCursor);
+    render();
+    timer = setInterval(render, SPINNER_INTERVAL_MS);
+  } else {
+    print(`${ICON.pending} ${label}`);
+  }
+
+  /**
+   * @param {string} icon - Final icon.
+   * @param {string} [finalLabel] - Final label; defaults to the current one.
+   */
+  const stop = (icon, finalLabel) => {
+    if (timer) {
+      clearInterval(timer);
+      process.stdout.write(`${ANSI_SEQUENCE.clearLine}${ANSI_SEQUENCE.showCursor}`);
+    }
+
+    print(`${icon} ${finalLabel ?? currentLabel} ${paint("gray", formatDuration(Date.now() - startedAt))}`);
+  };
+
+  return {
+    update(nextLabel) {
+      currentLabel = nextLabel;
+      if (!isInteractive) {
+        print(`${ICON.pending} ${nextLabel}`);
+      }
+    },
+    succeed: (finalLabel) => stop(ICON.success, finalLabel),
+    fail: (finalLabel) => stop(ICON.failure, finalLabel),
+  };
+}
+
+/**
+ * Restores the terminal and exits after Ctrl+C.
+ */
+function exitOnInterrupt() {
+  process.stdout.write(`${ANSI_SEQUENCE.showCursor}\n`);
+  print(`${ICON.warning} ${paint("yellow", "Release cancelado por el usuario. No se tocó nada más.")}`);
+  process.exit(INTERRUPTED_EXIT_CODE);
+}
+
+/**
+ * Counts the terminal rows that lines occupy, including the extra rows of
+ * lines wider than the terminal, so a prompt can erase exactly what it drew.
+ *
+ * @param {string[]} lines - Rendered lines, possibly styled.
+ * @param {number} columns - Terminal width in columns.
+ * @returns {number} Physical rows.
+ */
+export function countTerminalRows(lines, columns) {
+  const safeColumns = Math.max(columns, 1);
+  return lines.reduce((rows, line) => rows + Math.max(1, Math.ceil(visibleWidth(line) / safeColumns)), 0);
+}
+
+/**
+ * Maps a typed character to the option it selects.
+ *
+ * @param {string | undefined} text - Character typed by the user.
+ * @param {number} optionCount - Number of options in the prompt.
+ * @returns {number} Zero-based option index, or -1 when the key does not pick an option.
+ */
+export function resolveNumberKey(text, optionCount) {
+  if (!text || !NUMBER_KEY_PATTERN.test(text)) {
+    return -1;
+  }
+
+  const index = Number(text) - 1;
+  return index < Math.min(optionCount, MAX_NUMBERED_OPTIONS) ? index : -1;
+}
+
+/**
+ * Moves the selection of a prompt for a navigation key. Up and `k` go to the previous option;
+ * down, `j` and Tab to the next one, wrapping around. With nothing selected yet, the
+ * first "next" selects the first option and the first "previous" the last one.
+ *
+ * @param {number | null} selectedIndex - Selected option, or `null` when none is.
+ * @param {{ name?: string }} key - Parsed key.
+ * @param {number} optionCount - Number of options in the prompt.
+ * @returns {number | null} New selection; the same one when the key does not navigate.
+ */
+export function moveSelection(selectedIndex, key, optionCount) {
+  const keyName = key.name ?? "";
+
+  if (PROMPT_KEY.previous.includes(keyName)) {
+    return ((selectedIndex ?? 0) - 1 + optionCount) % optionCount;
+  }
+
+  if (PROMPT_KEY.next.includes(keyName)) {
+    return selectedIndex === null ? 0 : (selectedIndex + 1) % optionCount;
+  }
+
+  return selectedIndex;
+}
+
+/**
+ * Asks the user to choose one option: its number picks it right away, or the
+ * arrow keys move the selection and Enter confirms it. With `defaultIndex: null`
+ * nothing starts selected, so Enter does nothing until an option is picked.
+ *
+ * @param {{ message: string, options: SelectOption[], defaultIndex?: number | null }} prompt - Prompt; `description` renders on its own line below the option.
+ * @returns {Promise<string>} Selected value (the default one when stdin is not a TTY).
+ * @throws {Error} When stdin is not a TTY and there is no default option to answer with.
+ */
+export function select({ message, options, defaultIndex = 0 }) {
+  const input = process.stdin;
+  const question = `${paint(["bold", "cyan"], "?")} ${paint("bold", message)}`;
+
+  if (!input.isTTY) {
+    if (defaultIndex === null) {
+      return Promise.reject(new Error(`astra-rp:select "${message}" needs an explicit choice and stdin is not an interactive terminal`));
+    }
+
+    print(`${question} ${paint("gray", `→ ${options[defaultIndex].label} (sin terminal interactiva)`)}`);
+    return Promise.resolve(options[defaultIndex].value);
+  }
+
+  return new Promise((resolve) => {
+    const promptStartedAt = Date.now();
+    /** @type {number | null} */
+    let selectedIndex = defaultIndex;
+    let renderedLineCount = 0;
+
+    const render = () => {
+      const lines = [
+        question,
+        ...options.flatMap((option, index) => {
+          const isSelected = index === selectedIndex;
+          const pointer = isSelected ? ICON.arrow : " ";
+          const numberLabel = index < MAX_NUMBERED_OPTIONS ? `${index + 1}.` : "  ";
+          const number = isSelected ? paint(["bold", "magentaBright"], numberLabel) : paint("gray", numberLabel);
+          const label = isSelected ? paint(["bold", "magentaBright"], option.label) : option.label;
+          const hint = option.hint ? `  ${paint("gray", option.hint)}` : "";
+          const optionLine = `  ${pointer} ${number} ${label}${hint}`;
+          return option.description ? [optionLine, `       ${paint("gray", option.description)}`] : [optionLine];
+        }),
+        paint("gray", `  1-${Math.min(options.length, MAX_NUMBERED_OPTIONS)} para elegir · ↑/↓ y Enter para moverte y confirmar`),
+      ];
+      process.stdout.write(`${cursorUp(renderedLineCount)}\r${ANSI_SEQUENCE.clearBelow}${lines.join("\n")}\n`);
+      // Long lines wrap in the terminal: count physical rows so the next redraw erases all of them.
+      renderedLineCount = countTerminalRows(lines, process.stdout.columns || FALLBACK_TERMINAL_WIDTH);
+    };
+
+    /** @param {number} chosenIndex - Option confirmed by the user. */
+    const finish = (chosenIndex) => {
+      input.off("keypress", onKeypress);
+      input.setRawMode(false);
+      input.pause();
+      const chosen = options[chosenIndex];
+      process.stdout.write(`${cursorUp(renderedLineCount)}\r${ANSI_SEQUENCE.clearBelow}${ANSI_SEQUENCE.showCursor}`);
+      print(`${question} ${paint("magentaBright", chosen.label)}`);
+      promptWaitMs += Date.now() - promptStartedAt;
+      resolve(chosen.value);
+    };
+
+    /**
+     * @param {string | undefined} text - Typed character.
+     * @param {{ name?: string, ctrl?: boolean }} [key] - Parsed key.
+     */
+    const onKeypress = (text, key = {}) => {
+      const numberedIndex = resolveNumberKey(text, options.length);
+      const keyName = key.name ?? "";
+      const movedIndex = moveSelection(selectedIndex, key, options.length);
+
+      if (key.ctrl && keyName === PROMPT_KEY.interrupt) {
+        input.setRawMode(false);
+        exitOnInterrupt();
+      } else if (numberedIndex !== -1) {
+        finish(numberedIndex);
+      } else if (movedIndex !== selectedIndex) {
+        selectedIndex = movedIndex;
+        render();
+      } else if (PROMPT_KEY.confirm.includes(keyName) && selectedIndex !== null) {
+        finish(selectedIndex);
+      }
+    };
+
+    emitKeypressEvents(input);
+    input.setRawMode(true);
+    input.resume();
+    input.on("keypress", onKeypress);
+    process.stdout.write(ANSI_SEQUENCE.hideCursor);
+    render();
+  });
+}
+
+export { BOX_TONE, INTERRUPTED_EXIT_CODE };

package/src/testing.js

@@ -0,0 +1,70 @@
+/**
+ * Version bump fixtures for the test suites of every repository that uses
+ * `astra-rp`, so `create-version`, the Vercel build gate and any custom release
+ * command are checked against the same rule: from a stable version only the
+ * next patch, minor or major is allowed.
+ *
+ * @module testing
+ */
+
+/** Stable version every fixture bumps from. */
+export const CURRENT_STABLE_VERSION = "1.2.3";
+
+/** The only versions allowed after {@link CURRENT_STABLE_VERSION}: next patch, minor and major. */
+export const ALLOWED_NEXT_VERSIONS = Object.freeze(["1.2.4", "1.3.0", "2.0.0"]);
+
+/** Every rejected kind of bump from {@link CURRENT_STABLE_VERSION}, grouped by why it is rejected. */
+export const REJECTED_VERSION_BUMPS = Object.freeze({
+  unchanged: Object.freeze(["1.2.3"]),
+  lower: Object.freeze(["1.2.2", "1.1.9", "0.9.9", "1.2.0", "0.0.1"]),
+  "skips patches": Object.freeze(["1.2.5", "1.2.10"]),
+  "skips minors": Object.freeze(["1.4.0", "1.10.0"]),
+  "skips majors": Object.freeze(["3.0.0", "10.0.0"]),
+  "minor bump without resetting the patch": Object.freeze(["1.3.3", "1.3.1"]),
+  "major bump without resetting minor and patch": Object.freeze(["2.2.3", "2.0.3", "2.3.0", "2.0.1"]),
+  prerelease: Object.freeze([
+    "1.2.4-alpha",
+    "1.2.4-alpha.1",
+    "1.3.0-beta.2",
+    "2.0.0-rc.1",
+    "1.2.4-canary.0",
+    "1.2.4-next.3",
+    "1.2.4-dev",
+    "1.2.4-snapshot",
+    "1.2.4-0",
+    "1.2.4-alpha.beta.1",
+    "1.2.4-SNAPSHOT-20260926",
+  ]),
+  "build metadata": Object.freeze(["1.2.4+build.5", "1.3.0+sha.8fc0245", "2.0.0-beta.1+exp"]),
+  "not a plain X.Y.Z": Object.freeze([
+    "1.3",
+    "2",
+    "1.2.4.0",
+    "01.2.4",
+    "1.02.4",
+    "1.3.00",
+    "x.y.z",
+    "1.2.x",
+    "latest",
+    "",
+    " 1.2.4",
+    "1.2.4 ",
+    "v1.2.4",
+    "V1.2.4",
+    "^1.2.4",
+    "~1.3.0",
+    ">=2.0.0",
+    "1.2.4 || 1.3.0",
+  ]),
+});
+
+/**
+ * All rejected bumps as `[reason, version]` pairs for table-driven tests.
+ *
+ * @type {ReadonlyArray<readonly [string, string]>}
+ */
+export const REJECTED_VERSION_BUMP_CASES = Object.freeze(
+  Object.entries(REJECTED_VERSION_BUMPS).flatMap(([reason, versions]) =>
+    versions.map((version) => /** @type {const} */ ([reason, version]))
+  )
+);