reslop 0.2.6 → 0.3.0

package/lib/render/tiles.js

@@ -1,24 +1,32 @@
 'use strict';
 
-const ansi = require('../ansi.js');
-const { THEME, paint, visibleWidth, truncateVisible } = ansi;
+const { clamp } = require('../common/utilities.js');
+
+const {
+  THEME,
+  paint,
+  visibleWidth,
+  truncateVisible,
+} = require('../term/ansi.js');
 
 const GAP_X = 2;
 const GAP_Y = 1;
 const MIN_W = 34;
 const MIN_H = 6;
 const MAX_COLS = 4;
+const MAX_NORMAL = 3;
+const MAX_WIDE = 2;
 const RULE = '─';
 const ELLIPSIS = '…';
 const BAR_ON = '█';
 const BAR_OFF = '░';
-const SPARK = '▁▂▃▄▅▆▇█';
 const SPINNER = '⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏';
 
 const seg = (text, tone = 'text', bold = false) => ({
   text: `${text}`,
   tone,
   bold,
+  bg: null,
 });
 
 const toneColors = () => ({
@@ -30,8 +38,18 @@ const toneColors = () => ({
   warn: THEME.warnFg,
   error: THEME.errorFg,
   sha: THEME.shaFg,
-  trend: THEME.dashTrendFg,
+  dep: THEME.pkgDepFg,
+  dev: THEME.pkgDevFg,
+  pkg: THEME.pkgFg,
+  chain: THEME.pkgChainFg,
+  heat: THEME.heatFg,
+  heat1: THEME.heat1,
+  heat2: THEME.heat2,
+  heat3: THEME.heat3,
+  heat4: THEME.heat4,
+  blink: THEME.heatBlinkFg,
   key: THEME.dashKeyFg,
+  caption: THEME.dashCaptionFg,
 });
 
 const headColors = () => ({
@@ -78,13 +96,14 @@ const paintSegments = (segs, width, bg, color, fill = ' ', colors = null) => {
   }
   let out = '';
   for (const item of clipped) {
-    out += paint(item.text, ink[item.tone], bg, color, item.bold);
+    const pieceBg = item.bg ?? bg;
+    out += paint(item.text, ink[item.tone], pieceBg, color, item.bold);
   }
   return out + paint(fill.repeat(pad), ink.muted, bg, color);
 };
 
 const barSegments = (ratio, width, tone = 'add') => {
-  const clamped = Math.min(1, Math.max(0, Number.isFinite(ratio) ? ratio : 0));
+  const clamped = clamp(Number.isFinite(ratio) ? ratio : 0, 0, 1);
   const on = Math.round(clamped * width);
   return [
     seg(BAR_ON.repeat(on), tone),
@@ -92,52 +111,67 @@ const barSegments = (ratio, width, tone = 'add') => {
   ];
 };
 
-const sparkline = (values, width) => {
-  const count = values.length;
-  if (!count || width < 1) return '';
-  const max = Math.max(...values);
-  const top = SPARK.length - 1;
-  let out = '';
-  for (let i = 0; i < width; i++) {
-    const span = width <= 1 ? count - 1 : (i * (count - 1)) / (width - 1);
-    const at = Math.round(span);
-    const level = max > 0 ? Math.round((values[at] / max) * top) : 0;
-    out += SPARK[level];
-  }
-  return out;
+const RUN_ICON = {
+  passed: ['✔', 'add'],
+  failed: ['✖', 'error'],
+  aborted: ['⊘', 'muted'],
 };
 
 const spinner = (frame) => SPINNER[Math.abs(frame ?? 0) % SPINNER.length];
 
+const blinkTone = (frame) => (Math.abs(frame) % 2 ? 'hot' : 'warn');
+
 const spread = (total, parts) => {
   const base = Math.floor(total / parts);
   const extra = total % parts;
   return Array.from({ length: parts }, (_, i) => base + (i < extra ? 1 : 0));
 };
 
-const placeBand = (shown, from, size, width) => {
+const isWide = (tile) => tile.size === 'wide';
+
+const rowCap = (row, tile, maxCols) => {
+  const wide = isWide(tile) || row.some(isWide);
+  const cap = wide ? MAX_WIDE : MAX_NORMAL;
+  return Math.min(maxCols, cap);
+};
+
+const canFit = (row, tile, maxCols) => row.length < rowCap(row, tile, maxCols);
+
+const packRows = (shown, maxCols) => {
+  const rows = [];
+  let current = [];
+  for (const tile of shown) {
+    if (current.length && !canFit(current, tile, maxCols)) {
+      rows.push(current);
+      current = [];
+    }
+    current.push(tile);
+  }
+  if (current.length) rows.push(current);
+  return rows;
+};
+
+const placeBand = (row, width) => {
+  const size = row.length;
   const room = Math.max(0, width - (size - 1) * GAP_X);
   const widths = spread(room, size);
   const tiles = [];
   let x = 0;
   for (let i = 0; i < size; i++) {
-    tiles.push({ id: shown[from + i].id, x, w: widths[i] });
+    tiles.push({ id: row[i].id, x, w: widths[i] });
     x += widths[i] + GAP_X;
   }
   return tiles;
 };
 
-const placeTiles = (shown, cols, width, height) => {
-  const rows = Math.ceil(shown.length / cols);
-  const sizes = spread(shown.length, rows);
-  const heights = spread(height - (rows - 1) * GAP_Y, rows);
+const placePacked = (rows, width, height) => {
+  const count = Math.max(1, rows.length);
+  const heights = spread(height - (count - 1) * GAP_Y, count);
   const bands = [];
-  let from = 0;
   let y = 0;
-  for (let row = 0; row < rows; row++) {
-    const tiles = placeBand(shown, from, sizes[row], width);
+  for (let row = 0; row < rows.length; row++) {
+    const tiles = placeBand(rows[row], width);
     bands.push({ y, h: Math.max(1, heights[row]), tiles });
-    from += sizes[row];
     y += heights[row] + GAP_Y;
   }
   return bands;
@@ -145,16 +179,16 @@ const placeTiles = (shown, cols, width, height) => {
 
 const layoutTiles = (width, height, tiles) => {
   const cap = Math.floor((width + GAP_X) / (MIN_W + GAP_X));
-  const maxCols = Math.max(1, Math.min(MAX_COLS, cap));
+  const maxCols = clamp(cap, 1, MAX_COLS);
   const ranked = [...tiles].sort((left, right) => left.rank - right.rank);
   for (let count = tiles.length; count >= 1; count--) {
     const keep = new Set(ranked.slice(0, count).map((tile) => tile.id));
     const shown = tiles.filter((tile) => keep.has(tile.id));
-    const cols = Math.min(maxCols, count);
-    const rows = Math.ceil(count / cols);
-    const rowH = Math.floor((height - (rows - 1) * GAP_Y) / rows);
+    const rows = packRows(shown, maxCols);
+    const n = rows.length;
+    const rowH = Math.floor((height - (n - 1) * GAP_Y) / n);
     if (rowH >= MIN_H || count === 1) {
-      return placeTiles(shown, cols, width, height);
+      return placePacked(rows, width, height);
     }
   }
   return [];
@@ -173,9 +207,15 @@ const paintFramed = (line, width, bg, color, fill = ' ', colors = null) => {
   return edge + paintSegments(line, inner, bg, color, fill, colors) + edge;
 };
 
-const paintHead = (tile, content, width, color) => {
+const paintFlushRight = (line, width, bg, color) => {
+  const edge = paintSegments([seg(' ')], 1, bg, color);
+  const inner = Math.max(0, width - 1);
+  return edge + paintSegments(line, inner, bg, color);
+};
+
+const paintHead = (tile, content, width, color, headBg) => {
   const fill = color ? ' ' : RULE;
-  const bg = THEME.dashHeadBg;
+  const bg = headBg;
   const colors = headColors();
   if (content.titleLine) {
     return paintFramed(content.titleLine, width, bg, color, fill, colors);
@@ -184,22 +224,58 @@ const paintHead = (tile, content, width, color) => {
   return paintSegments(segs, width, bg, color, fill, colors);
 };
 
-const rowBackground = (index, filled) => {
-  if (filled && index % 2 === 1) return THEME.dashRowBg;
-  return THEME.dashTileBg;
+const rowBackground = (index, filled, backs) => {
+  if (filled && index % 2 === 1) return backs.row;
+  return backs.tile;
+};
+
+const centeredSegments = (line, room) => {
+  const clipped = clipSegments(line, room);
+  const pad = Math.floor((room - segmentsWidth(clipped)) / 2);
+  if (pad < 1) return clipped;
+  return [seg(' '.repeat(pad)), ...clipped];
+};
+
+const centeredBody = (lines, room, inner) => {
+  const count = Math.min(lines.length, room);
+  const start = Math.floor((room - count) / 2);
+  const rows = [];
+  for (let i = 0; i < room; i++) {
+    const at = i - start;
+    const line = at >= 0 && at < count ? lines[at] : null;
+    if (!line || !line.length) {
+      rows.push([]);
+      continue;
+    }
+    rows.push(centeredSegments(line, inner));
+  }
+  return rows;
 };
 
-const paintTile = (tile, content, width, height, color) => {
-  const { lines, footer } = content;
-  const rows = [paintHead(tile, content, width, color)];
+const paintTile = (tile, content, width, height, color, backs = null) => {
+  const shade = backs ?? {
+    head: THEME.dashHeadBg,
+    tile: THEME.dashTileBg,
+    row: THEME.dashRowBg,
+  };
+  const lines = content.lines ?? [];
+  const { footer } = content;
+  const rows = [paintHead(tile, content, width, color, shade.head)];
   const bodyRoom = footer ? height - 2 : height - 1;
+  const inner = Math.max(0, width - 2);
+  const centered = content.center ? centeredBody(lines, bodyRoom, inner) : null;
   for (let i = 0; i < bodyRoom; i++) {
-    const bg = rowBackground(i, i < lines.length);
-    rows.push(paintFramed(lines[i] ?? [], width, bg, color));
+    let line = [];
+    if (centered) line = centered[i];
+    else if (lines[i]) line = lines[i];
+    const filled = !centered && i < lines.length;
+    const bg = rowBackground(i, filled, shade);
+    rows.push(paintFramed(line, width, bg, color));
   }
   if (footer && height > 1) {
-    const bg = rowBackground(bodyRoom, true);
-    rows.push(paintFramed(footer, width, bg, color));
+    const bg = rowBackground(bodyRoom, true, shade);
+    const paintRow = content.footerFlush ? paintFlushRight : paintFramed;
+    rows.push(paintRow(footer, width, bg, color));
   }
   return rows;
 };
@@ -229,6 +305,81 @@ const composeBands = (bands, painted, width, height, color) => {
   return rows.slice(0, height);
 };
 
+const gridSize = (width, height, cols, rows) => ({
+  tileW: Math.floor((width - (cols - 1) * GAP_X) / cols),
+  tileH: Math.floor((height - (rows - 1) * GAP_Y) / rows),
+});
+
+const equalGrid = (width, height, count, minW = MIN_W, minH = MIN_H) => {
+  const safe = Math.max(1, count);
+  const colCap = Math.max(
+    1,
+    Math.min(safe, Math.floor((width + GAP_X) / (minW + GAP_X)) || 1),
+  );
+  const rowCap = Math.max(
+    1,
+    Math.min(safe, Math.floor((height + GAP_Y) / (minH + GAP_Y)) || 1),
+  );
+  let best = null;
+  for (let cols = 1; cols <= colCap; cols++) {
+    for (let rows = 1; rows <= rowCap; rows++) {
+      const size = gridSize(width, height, cols, rows);
+      if (size.tileW < minW || size.tileH < minH) continue;
+      const cap = cols * rows;
+      const shown = Math.min(safe, cap);
+      const score = shown * 1000000 + size.tileW * size.tileH;
+      if (!best || score > best.score) {
+        best = { width, cols, rows, cap, ...size, score };
+      }
+    }
+  }
+  if (best) return best;
+  return {
+    width,
+    cols: 1,
+    rows: 1,
+    cap: 1,
+    tileW: Math.max(1, width),
+    tileH: Math.max(1, height),
+    score: 0,
+  };
+};
+
+const pageWindow = (count, cursor, cap) => {
+  const room = Math.max(1, cap);
+  if (count <= room) return { start: 0, end: count };
+  const at = clamp(cursor, 0, count - 1);
+  let start = Math.floor(at / room) * room;
+  if (start + room > count) start = count - room;
+  return { start, end: start + room };
+};
+
+const placeEqualTiles = (tiles, grid) => {
+  const bands = [];
+  const cols = Math.max(1, grid.cols);
+  const rows = Math.ceil(tiles.length / cols);
+  const gaps = Math.max(0, cols - 1) * GAP_X;
+  const full = grid.width ?? cols * grid.tileW + gaps;
+  const room = Math.max(0, full - gaps);
+  const widths = spread(room, cols);
+  for (let row = 0; row < rows; row++) {
+    const slice = tiles.slice(row * cols, (row + 1) * cols);
+    if (!slice.length) break;
+    const placed = [];
+    let x = 0;
+    for (let i = 0; i < slice.length; i++) {
+      const w = widths[i];
+      placed.push({ id: slice[i].id, x, w });
+      x += w + GAP_X;
+    }
+    const y = row * (grid.tileH + GAP_Y);
+    const h = grid.tileH;
+    const band = { y, h, tiles: placed };
+    bands.push(band);
+  }
+  return bands;
+};
+
 const tileHits = (bands, headerLines) => {
   const hits = [];
   for (const band of bands) {
@@ -249,10 +400,15 @@ module.exports = {
   segmentsWidth,
   clipSegments,
   barSegments,
-  sparkline,
+  RUN_ICON,
   spinner,
+  blinkTone,
   titleSegments,
   layoutTiles,
+  equalGrid,
+  pageWindow,
+  placeEqualTiles,
+  paintSegments,
   paintTile,
   composeBands,
   tileHits,

package/lib/render/unit.js

@@ -1,14 +1,14 @@
 'use strict';
 
-const detect = require('../detect.js');
-const diffLib = require('../diff/diff.js');
-const primitives = require('./primitives.js');
-const diff = require('./diff.js');
-
-const { detectLang } = detect;
-const { sameHunk } = diffLib;
-const { paneResult } = primitives;
-const { paintDiffLine, expandSoftRows, codeHits } = diff;
+const { detectLang } = require('../highlight/highlight.js');
+const { sameHunk } = require('../diff/diff.js');
+const { paneResult, lazyRows } = require('./primitives.js');
+const {
+  paintDiffLine,
+  expandSoftRows,
+  codeHits,
+  viewDigits,
+} = require('./diff.js');
 
 const paintBodyUnit = (view, width, color) => {
   const { item, codeOverlay: overlay } = view;
@@ -17,14 +17,33 @@ const paintBodyUnit = (view, width, color) => {
     view.mode === 'compose' && typeof overlay?.cursor === 'number';
   const scrollCol = (editing ? overlay.scrollCol : 0) ?? 0;
   const lines = view.unitLines ?? [];
-  const source = editing ? lines : expandSoftRows(lines, width, false, true);
-  const body = source.map((line) => {
+  const digits = viewDigits(view);
+  let source = lines;
+  if (!editing) source = expandSoftRows(lines, width, false, true, digits);
+  const body = lazyRows(source.length, (index) => {
+    const line = source[index];
     const changed = line.type === 'add' || line.type === 'del';
     const outside = changed && !(item && sameHunk(line.item, item));
     const row = editing || outside ? { ...line, mark: ' ' } : line;
-    return paintDiffLine(row, width, color, row.origin, lang, scrollCol);
+    return paintDiffLine(
+      row,
+      width,
+      color,
+      row.origin,
+      lang,
+      scrollCol,
+      digits,
+    );
   });
-  const hits = codeHits(source, false, width, overlay, editing, scrollCol);
+  const hits = codeHits(
+    source,
+    false,
+    width,
+    overlay,
+    editing,
+    scrollCol,
+    digits,
+  );
   return paneResult({ body, ...hits });
 };
 

package/lib/{report-model.js → report/model.js}

@@ -1,10 +1,8 @@
 'use strict';
 
-const ansi = require('./ansi.js');
-const { stripAnsi } = ansi;
-const commands = require('./npm-commands.js');
-
-const { traceLine, relativize } = commands;
+const { stripAnsi } = require('../term/ansi.js');
+const { traceLine, relativize } = require('../runs/output.js');
+const { trimText } = require('../common/utilities.js');
 
 const summary = () => ({
   tests: null,
@@ -59,7 +57,7 @@ const userTrace = (text, root) => {
 };
 
 const normalizeMessage = (message) => {
-  const text = `${message ?? ''}`.trim().replace(/\s+/g, ' ');
+  const text = trimText(message).replace(/\s+/g, ' ');
   return text.replace(/\s+\S+:\d+:\d+$/, '');
 };
 

package/lib/{report-parse.js → report/parse.js}

@@ -1,10 +1,10 @@
 'use strict';
 
-const ansi = require('./ansi.js');
-const { stripAnsi } = ansi;
-const model = require('./report-model.js');
-const testParse = require('./report-test.js');
-const toolParse = require('./report-tools.js');
+const { jsonParse } = require('metautil');
+const { stripAnsi } = require('../term/ansi.js');
+const model = require('./model.js');
+const testParse = require('./test.js');
+const toolParse = require('./tools.js');
 
 const { problem, report, userTrace, groupReport, envelope } = model;
 const { parseTap, parseNodeJsonl, parseTestJson, parseSpec } = testParse;
@@ -27,11 +27,7 @@ const toolHint = (program, args) => {
 const parseJson = (text) => {
   const trimmed = text.trim();
   if (!trimmed || (trimmed[0] !== '{' && trimmed[0] !== '[')) return null;
-  try {
-    return JSON.parse(trimmed);
-  } catch {
-    return null;
-  }
+  return jsonParse(trimmed);
 };
 
 const parseJsonReports = (text, root) => {
@@ -91,10 +87,9 @@ const mergeReports = (left, right) => {
 const buildDocument = (stdout, stderr, root, exit, hint) => {
   const out = stripAnsi(stdout);
   const err = stripAnsi(stderr);
-  const reports = mergeReports(
-    parseReports(out, root),
-    parseReports(err, root),
-  );
+  const fromOut = parseReports(out, root);
+  const fromErr = parseReports(err, root);
+  const reports = mergeReports(fromOut, fromErr);
   const text = out.trim() ? out : err;
   const grouped = withHint(reports, text, exit, hint).map(groupReport);
   const rest = stderrRest(err, grouped);

package/lib/{report-render.js → report/render.js}

@@ -1,16 +1,15 @@
 'use strict';
 
-const utilities = require('./utilities.js');
-const { unquote } = utilities;
+const { unquote } = require('../common/utilities.js');
+const { formatTable } = require('../runs/output.js');
 
 const NOTICE_HEAD =
   'reslop: reduced output; passing results are omitted ' +
   'and similar problems are grouped';
 
 const notice = (rawFile) => {
-  const target = rawFile
-    ? `the raw log \`.log/${rawFile}\``
-    : 'the matching raw log under `.log/`';
+  let target = 'the matching raw log under `.log/`';
+  if (rawFile) target = `the raw log \`.log/${rawFile}\``;
   const hint = `Agent: if this report hides a needed detail, read ${target}.`;
   return `${NOTICE_HEAD}\n${hint}`;
 };
@@ -38,12 +37,12 @@ const sameValue = (line, value) => {
   return text === value || unquote(text) === value;
 };
 
-const startsDiff = (line, item) =>
-  isComparison(line) ||
-  isDiffHeader(line) ||
-  isMarkedDiff(line) ||
-  sameValue(line, item.expected) ||
-  sameValue(line, item.actual);
+const startsDiff = (line, item) => {
+  if (isComparison(line) || isDiffHeader(line)) return true;
+  if (isMarkedDiff(line)) return true;
+  if (sameValue(line, item.expected)) return true;
+  return sameValue(line, item.actual);
+};
 
 const displayMessage = (item) => {
   const values = item.expected !== '' || item.actual !== '';
@@ -135,13 +134,46 @@ const loggedText = (text, rawFile) => {
   return `${head}\n\n${body}`;
 };
 
+const reportProblem = (item) => {
+  const title = item.name || item.message || item.code || 'problem';
+  const mark = item.severity === 'warning' ? '△' : '✖';
+  const count = item.count > 1 ? `  × ${item.count}` : '';
+  const lines = ['', `${mark} ${title.split('\n')[0]}${count}`, ''];
+  lines.push(...formatTable(problemRows(item)));
+  const message = displayMessage(item);
+  if (message) lines.push('', ...quoteLines(message));
+  if (item.trace) {
+    lines.push('', 'Stack');
+    for (const row of item.trace.split(/\r?\n/)) {
+      const frame = row.trim().replace(/^at\s+/, '');
+      if (frame) lines.push(`  at ${frame}`);
+    }
+  }
+  if (item.related.length) {
+    lines.push('', 'Related failures');
+    for (const row of item.related) lines.push(`  ↳ ${row}`);
+  }
+  return lines;
+};
+
+const renderReport = (doc) => {
+  const lines = [];
+  for (const item of doc.reports) {
+    if (lines.length) lines.push('');
+    const mark = item.ok ? '✔' : '✖';
+    lines.push(`${mark} ${item.tool}  ·  exit ${doc.exit}`, '');
+    lines.push(...formatTable(summaryRows(item.summary)));
+    for (const entry of item.problems) lines.push(...reportProblem(entry));
+  }
+  if (doc.stderr) lines.push('', 'Stderr', doc.stderr);
+  return `${lines.join('\n')}\n`;
+};
+
 module.exports = {
   NOTICE_HEAD,
   notice,
-  summaryRows,
-  problemRows,
   displayMessage,
-  quoteLines,
   loggedText,
   renderDocument,
+  renderReport,
 };