u-foo 2.5.15 → 3.0.0

package/src/ui/format/markdownRenderer.js

@@ -3,7 +3,8 @@
  *
  * Produces either blessed tags (chat / legacy) or chalk ANSI (Ink ucode).
  * Terminals cannot change font size, so headings/emphasis use color + weight
- * instead of literal `#` / `**` markers.
+ * instead of literal `#` / `**` markers. GFM pipe tables are aligned into a
+ * compact spreadsheet-like grid.
  */
 
 const chalk = require("chalk");
@@ -15,6 +16,116 @@ function stripLeakedEscapeTags(text = "") {
   return withoutDanglingEscape.replace(/\{\s*\/?\s*e?s?c?a?p?e?[^{}\n]*$/gi, "");
 }
 
+/** Visible width for CJK-aware table padding (no ANSI). */
+function visibleWidth(text = "") {
+  let width = 0;
+  for (const char of String(text || "")) {
+    const code = char.codePointAt(0) || 0;
+    if (code < 32 || (code >= 0x7f && code < 0xa0)) continue;
+    if (
+      (code >= 0x1100 && code <= 0x115f)
+      || code === 0x2329
+      || code === 0x232a
+      || (code >= 0x2e80 && code <= 0xa4cf)
+      || (code >= 0xac00 && code <= 0xd7a3)
+      || (code >= 0xf900 && code <= 0xfaff)
+      || (code >= 0xfe10 && code <= 0xfe19)
+      || (code >= 0xfe30 && code <= 0xfe6f)
+      || (code >= 0xff00 && code <= 0xff60)
+      || (code >= 0xffe0 && code <= 0xffe6)
+    ) {
+      width += 2;
+      continue;
+    }
+    width += 1;
+  }
+  return width;
+}
+
+function isTableSeparatorLine(line = "") {
+  const raw = String(line || "").trim();
+  if (!raw.includes("-")) return false;
+  return /^\|?(\s*:?-+:?\s*\|)+\s*:?-+:?\s*\|?$/.test(raw);
+}
+
+function isTableRowLine(line = "") {
+  const raw = String(line || "").trim();
+  if (!raw.includes("|")) return false;
+  if (isTableSeparatorLine(raw)) return true;
+  // Prefer GFM pipe rows (`| a | b |`). Also allow compact `a | b | c`
+  // (at least two pipes). Lone prose like `A | B` is not a table row.
+  if (/^\|.*\|$/.test(raw)) return true;
+  const parts = raw.split("|");
+  return parts.length >= 3 && parts.some((p) => p.trim().length > 0);
+}
+
+/**
+ * Buffers consecutive GFM table rows so they can be rendered as one block
+ * (column widths need the full table). Call flush() before non-table output.
+ */
+function createMarkdownTableBuffer() {
+  const rows = [];
+  return {
+    get size() {
+      return rows.length;
+    },
+    push(line = "") {
+      const raw = String(line == null ? "" : line);
+      if (!isTableRowLine(raw)) return false;
+      rows.push(raw);
+      return true;
+    },
+    flush() {
+      if (rows.length === 0) return null;
+      const text = rows.join("\n");
+      rows.length = 0;
+      return text;
+    },
+  };
+}
+
+function parseTableCells(line = "") {
+  let raw = String(line || "").trim();
+  if (raw.startsWith("|")) raw = raw.slice(1);
+  if (raw.endsWith("|")) raw = raw.slice(0, -1);
+  return raw.split("|").map((cell) => cell.trim());
+}
+
+function parseSeparatorAlignments(line = "", columnCount = 0) {
+  const cells = parseTableCells(line);
+  const aligns = cells.map((cell) => {
+    const left = cell.startsWith(":");
+    const right = cell.endsWith(":");
+    if (left && right) return "center";
+    if (right) return "right";
+    return "left";
+  });
+  while (aligns.length < columnCount) aligns.push("left");
+  return aligns.slice(0, Math.max(columnCount, aligns.length));
+}
+
+function alignCell(text = "", width = 0, align = "left") {
+  const value = String(text || "");
+  const current = visibleWidth(value);
+  if (current >= width) return value;
+  const pad = width - current;
+  if (align === "right") return `${" ".repeat(pad)}${value}`;
+  if (align === "center") {
+    const left = Math.floor(pad / 2);
+    const right = pad - left;
+    return `${" ".repeat(left)}${value}${" ".repeat(right)}`;
+  }
+  return `${value}${" ".repeat(pad)}`;
+}
+
+function plainCellWidth(cell = "") {
+  const plain = String(cell || "")
+    .replace(/\*\*|__/g, "")
+    .replace(/`/g, "")
+    .replace(/\*/g, "");
+  return visibleWidth(plain);
+}
+
 function createBlessedAdapters(escapeFn = (value) => String(value || "")) {
   const escape = (value) => escapeFn(value);
   return {
@@ -40,6 +151,11 @@ function createBlessedAdapters(escapeFn = (value) => String(value || "")) {
     fenceClose: () => "{gray-fg}└{/gray-fg}",
     fenceBody: (value) => `{gray-fg}│{/gray-fg} {white-fg}${escape(value)}{/white-fg}`,
     error: (value) => `{red-fg}${value}{/red-fg}`,
+    tablePipe: () => "{gray-fg}│{/gray-fg}",
+    tableSepCross: () => "{gray-fg}┼{/gray-fg}",
+    tableSepH: () => "{gray-fg}─{/gray-fg}",
+    tableHeaderCell: (value) => `{bold}{white-fg}${value}{/white-fg}{/bold}`,
+    tableCell: (value) => value,
   };
 }
 
@@ -76,6 +192,11 @@ function createAnsiAdapters() {
     fenceClose: () => paint.gray("└"),
     fenceBody: (value) => `${paint.gray("│")} ${paint.white(String(value || ""))}`,
     error: (value) => paint.red(String(value || "")),
+    tablePipe: () => paint.gray("│"),
+    tableSepCross: () => paint.gray("┼"),
+    tableSepH: () => paint.gray("─"),
+    tableHeaderCell: (value) => paint.bold.whiteBright(String(value || "")),
+    tableCell: (value) => String(value || ""),
   };
 }
 
@@ -161,6 +282,82 @@ function renderInlineMarkdown(input = "", adapters = createBlessedAdapters()) {
   return out;
 }
 
+function renderTableBlock(rawRows = [], adapters = createBlessedAdapters()) {
+  if (!Array.isArray(rawRows) || rawRows.length === 0) return [];
+
+  const rows = [];
+  let alignments = [];
+  let headerUsed = false;
+
+  for (let i = 0; i < rawRows.length; i += 1) {
+    const line = rawRows[i];
+    if (isTableSeparatorLine(line)) {
+      if (rows.length > 0 && !headerUsed) {
+        rows[rows.length - 1].isHeader = true;
+        headerUsed = true;
+      }
+      alignments = parseSeparatorAlignments(line, Math.max(alignments.length, parseTableCells(line).length));
+      continue;
+    }
+    rows.push({
+      cells: parseTableCells(line),
+      isHeader: false,
+    });
+  }
+
+  if (rows.length === 0) return [];
+
+  const columnCount = rows.reduce((max, row) => Math.max(max, row.cells.length), 0);
+  while (alignments.length < columnCount) alignments.push("left");
+
+  const widths = Array.from({ length: columnCount }, () => 1);
+  for (const row of rows) {
+    for (let c = 0; c < columnCount; c += 1) {
+      widths[c] = Math.max(widths[c], plainCellWidth(row.cells[c] || ""));
+    }
+  }
+
+  const pipe = adapters.tablePipe || (() => "│");
+  const sepH = adapters.tableSepH || (() => "─");
+  const sepCross = adapters.tableSepCross || (() => "┼");
+  const styleHeader = adapters.tableHeaderCell || ((v) => v);
+  const styleCell = adapters.tableCell || ((v) => v);
+
+  const out = [];
+  let wroteHeaderSep = false;
+
+  for (const row of rows) {
+    const renderedCells = [];
+    for (let c = 0; c < columnCount; c += 1) {
+      const rawCell = row.cells[c] || "";
+      const inline = renderInlineMarkdown(rawCell, adapters);
+      const plain = String(rawCell)
+        .replace(/\*\*|__/g, "")
+        .replace(/`/g, "")
+        .replace(/\*/g, "");
+      const alignedPlain = alignCell(plain, widths[c], alignments[c] || "left");
+      const padRight = Math.max(0, visibleWidth(alignedPlain) - visibleWidth(plain));
+      const styled = row.isHeader ? styleHeader(inline) : styleCell(inline);
+      renderedCells.push(`${styled}${" ".repeat(padRight)}`);
+    }
+    out.push(`${pipe()} ${renderedCells.join(` ${pipe()} `)} ${pipe()}`);
+
+    if (row.isHeader && !wroteHeaderSep) {
+      const segments = widths.map((w) => {
+        const unit = sepH();
+        // sepH may be a styled string longer than 1 codepoint; repeat by width.
+        return unit.repeat(Math.max(1, w));
+      });
+      out.push(
+        `${pipe()}${sepH()}${segments.join(`${sepH()}${sepCross()}${sepH()}`)}${sepH()}${pipe()}`,
+      );
+      wroteHeaderSep = true;
+    }
+  }
+
+  return out;
+}
+
 function renderMarkdownLinesWithAdapters(text = "", state = {}, adapters = createBlessedAdapters()) {
   const renderState = state && typeof state === "object" ? state : {};
   if (typeof renderState.inCodeBlock !== "boolean") {
@@ -170,7 +367,8 @@ function renderMarkdownLinesWithAdapters(text = "", state = {}, adapters = creat
   const lines = String(text || "").split(/\r?\n/);
   const out = [];
 
-  for (const line of lines) {
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
     const raw = stripLeakedEscapeTags(String(line || ""));
     const fenceMatch = raw.match(/^(\s*)(`{3,}|~{3,})(.*)$/);
     if (fenceMatch) {
@@ -190,6 +388,24 @@ function renderMarkdownLinesWithAdapters(text = "", state = {}, adapters = creat
       continue;
     }
 
+    // GFM table block — collect contiguous pipe rows for column alignment.
+    if (isTableRowLine(raw)) {
+      const block = [raw];
+      let look = index + 1;
+      while (look < lines.length) {
+        const nextRaw = stripLeakedEscapeTags(String(lines[look] || ""));
+        if (!isTableRowLine(nextRaw)) break;
+        block.push(nextRaw);
+        look += 1;
+      }
+      const hasSep = block.some((row) => isTableSeparatorLine(row));
+      if (hasSep || block.length >= 2) {
+        out.push(...renderTableBlock(block, adapters));
+        index = look - 1;
+        continue;
+      }
+    }
+
     if (/^\s*(-{3,}|\*{3,}|_{3,})\s*$/.test(raw)) {
       out.push(adapters.rule());
       continue;
@@ -261,4 +477,10 @@ module.exports = {
   renderMarkdownLinesWithAdapters,
   createBlessedAdapters,
   createAnsiAdapters,
+  isTableRowLine,
+  isTableSeparatorLine,
+  parseTableCells,
+  renderTableBlock,
+  createMarkdownTableBuffer,
+  visibleWidth,
 };