reslop 0.2.7 → 0.3.0

package/lib/render/status.json

@@ -0,0 +1,85 @@
+{
+  "busy": [
+    "pulling",
+    "pushing",
+    "loading",
+    "importing",
+    "checking npm",
+    "updating reslop",
+    "npm i",
+    "npm uninstall",
+    "npm audit fix",
+    "running",
+    "checking out",
+    "creating branch",
+    "rebasing",
+    "dropping",
+    "committing",
+    "updating",
+    "rewording",
+    "force pushing"
+  ],
+  "info": [
+    "copied",
+    "staged",
+    "unstaged",
+    "not staged",
+    "dropped",
+    "already staged",
+    "read only",
+    "transitive",
+    "nothing to review",
+    "nothing to commit",
+    "not installed",
+    "no plan",
+    "returned",
+    "stopped",
+    "started",
+    "unified",
+    "mixed",
+    "side-by-side",
+    "line numbers",
+    "no line numbers",
+    "dark",
+    "light",
+    "saved",
+    "reloaded",
+    "not a diff block",
+    "file scope",
+    "diff mode",
+    "committed",
+    "amended",
+    "reworded",
+    "fixup",
+    "updated",
+    "imported",
+    "pulled",
+    "pushed",
+    "force pushed",
+    "checked out",
+    "created",
+    "empty branch name",
+    "empty commit message",
+    "terminated",
+    "verbose",
+    "filtered",
+    "fast on",
+    "fast off",
+    "logged in",
+    "logging in",
+    "ignored",
+    "already ignored",
+    "brief",
+    "full"
+  ],
+  "infoPrefix": [
+    "checked out ",
+    "created ",
+    "rebased onto ",
+    "dropped ",
+    "exit ",
+    "model ",
+    "updated ",
+    "installed "
+  ]
+}

package/lib/render/{dash-table.js → table.js}

@@ -1,45 +1,12 @@
 'use strict';
 
-const metautil = require('metautil');
-const { bytesToSize } = metautil;
-const files = require('../files.js');
-const { relativeAge } = files;
-const ansi = require('../ansi.js');
-const { visibleWidth, graphemes, graphemeWidth } = ansi;
+const { num } = require('../common/format.js');
+const { visibleWidth, graphemes, graphemeWidth } = require('../term/ansi.js');
 const tiles = require('./tiles.js');
 const { seg, segmentsWidth, clipSegments, titleSegments } = tiles;
-const tree = require('../dashboard/tree.js');
-const { HEAT_MS } = tree;
+const { HEAT_MS } = require('../dashboard/tree.js');
 
 const MIN_FLEX = 6;
-const SECONDS_AGO = /^\d+s ago$/;
-
-const trimmed = (value) =>
-  value >= 10 ? `${Math.round(value)}` : `${Math.round(value * 10) / 10}`;
-
-const num = (value) => {
-  const n = Math.max(0, Math.round(value));
-  if (n >= 1e6) return `${trimmed(n / 1e6)}m`;
-  if (n >= 1e4) return `${trimmed(n / 1e3)}k`;
-  return `${n}`;
-};
-
-const size = (bytes) => bytesToSize(bytes > 0 ? bytes : 0);
-
-const ago = (at, now) => {
-  if (!at) return '';
-  const text = relativeAge(at, now);
-  return SECONDS_AGO.test(text) ? '<1m ago' : text;
-};
-
-const duration = (ms) => {
-  const value = Math.max(0, ms);
-  if (value < 1000) return `${Math.round(value)}ms`;
-  if (value < 60000) return `${(value / 1000).toFixed(1)}s`;
-  const minutes = Math.floor(value / 60000);
-  const seconds = Math.floor((value % 60000) / 1000);
-  return `${minutes}m${`${seconds}`.padStart(2, '0')}s`;
-};
 
 const isHot = (at, now) => at > 0 && now - at < HEAT_MS;
 
@@ -49,7 +16,15 @@ const delta = (value, now, at) => {
   return seg(`▼${num(-value)}`, 'del', true);
 };
 
-const waiting = (text) => ({ badge: [], lines: [[seg(text, 'muted')]] });
+const notice = (text, titleLine) => {
+  const rows = Array.isArray(text) ? text : [text];
+  const lines = rows.map((row) => [seg(row, 'muted')]);
+  const block = { badge: [], center: true, lines };
+  if (titleLine) block.titleLine = titleLine;
+  return block;
+};
+
+const waiting = (text) => notice(text);
 
 const cell = (text, tone = 'text', align = 'l', bold = false) => ({
   segs: [seg(text, tone, bold)],
@@ -246,23 +221,6 @@ const titleAside = (tile, aside, width, badge = []) => {
   return [...left, seg(' '.repeat(Math.max(1, gap))), ...aside];
 };
 
-const stat = (label, value, tone = 'text', bold = false) => ({
-  label,
-  value: typeof value === 'string' ? [seg(value, tone, bold)] : value,
-});
-
-const pairRows = (items, perRow = 2) => {
-  const rows = [];
-  for (let i = 0; i < items.length; i += perRow) {
-    const row = [];
-    for (const item of items.slice(i, i + perRow)) {
-      row.push(cell(item.label, 'muted'), cellSegs(item.value));
-    }
-    rows.push(row);
-  }
-  return rows;
-};
-
 const pickGroups = (folders, exts, rows) => {
   const count = Math.max(0, rows);
   const dirs = folders.slice(0, count);
@@ -275,19 +233,14 @@ const labelOf = (key, isDir) => {
 };
 
 module.exports = {
-  num,
-  size,
-  ago,
-  duration,
   isHot,
   delta,
+  notice,
   waiting,
   cell,
   cellSegs,
   flexCell,
   tableLines,
-  stat,
-  pairRows,
   pickGroups,
   labelOf,
   titleAside,

package/lib/render/tiles.js

@@ -1,18 +1,25 @@
 '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) => ({
@@ -36,8 +43,13 @@ const toneColors = () => ({
   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 = () => ({
@@ -91,7 +103,7 @@ const paintSegments = (segs, width, bg, color, fill = ' ', colors = null) => {
 };
 
 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),
@@ -99,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;
@@ -152,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 [];
@@ -202,18 +229,48 @@ const rowBackground = (index, filled, backs) => {
   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, backs = null) => {
   const shade = backs ?? {
     head: THEME.dashHeadBg,
     tile: THEME.dashTileBg,
     row: THEME.dashRowBg,
   };
-  const { lines, footer } = content;
+  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, shade);
-    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, shade);
@@ -272,12 +329,13 @@ const equalGrid = (width, height, count, minW = MIN_W, minH = MIN_H) => {
       const shown = Math.min(safe, cap);
       const score = shown * 1000000 + size.tileW * size.tileH;
       if (!best || score > best.score) {
-        best = { cols, rows, cap, ...size, score };
+        best = { width, cols, rows, cap, ...size, score };
       }
     }
   }
   if (best) return best;
   return {
+    width,
     cols: 1,
     rows: 1,
     cap: 1,
@@ -290,7 +348,7 @@ const equalGrid = (width, height, count, minW = MIN_W, minH = MIN_H) => {
 const pageWindow = (count, cursor, cap) => {
   const room = Math.max(1, cap);
   if (count <= room) return { start: 0, end: count };
-  const at = Math.min(Math.max(0, cursor), count - 1);
+  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 };
@@ -300,22 +358,24 @@ 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++) {
-      placed.push({
-        id: slice[i].id,
-        x: i * (grid.tileW + GAP_X),
-        w: grid.tileW,
-      });
+      const w = widths[i];
+      placed.push({ id: slice[i].id, x, w });
+      x += w + GAP_X;
     }
-    bands.push({
-      y: row * (grid.tileH + GAP_Y),
-      h: grid.tileH,
-      tiles: placed,
-    });
+    const y = row * (grid.tileH + GAP_Y);
+    const h = grid.tileH;
+    const band = { y, h, tiles: placed };
+    bands.push(band);
   }
   return bands;
 };
@@ -340,8 +400,9 @@ module.exports = {
   segmentsWidth,
   clipSegments,
   barSegments,
-  sparkline,
+  RUN_ICON,
   spinner,
+  blinkTone,
   titleSegments,
   layoutTiles,
   equalGrid,

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);