reslop 0.2.5 → 0.2.6

package/lib/render/dash-activity.js

@@ -0,0 +1,212 @@
+'use strict';
+
+const tiles = require('./tiles.js');
+const { seg, spinner } = tiles;
+const table = require('./dash-table.js');
+const { ago, duration, isHot, waiting, cell, cellSegs, flexCell } = table;
+const { tableLines, stat, pairRows, titleAside, captionOver } = table;
+
+const NAME_MAX = 18;
+const RUN_ICON = {
+  passed: ['✔', 'add'],
+  failed: ['✖', 'error'],
+  aborted: ['⊘', 'muted'],
+};
+
+const blankCell = () => cell('', 'muted', 'r');
+
+const ageCell = (at, now) => cell(at ? ago(at, now) : '', 'muted', 'r');
+
+const rebaseStep = (rebase) => {
+  const total = rebase.total ? `/${rebase.total}` : '';
+  return `${rebase.step || '?'}${total}`;
+};
+
+const commitRow = (entry, ctx, hot) => [
+  cell(entry.short, hot ? 'warn' : 'sha', 'l', true),
+  flexCell(entry.subject, hot ? 'warn' : 'text'),
+  ageCell(entry.at, ctx.now),
+];
+
+const commitsBlock = (model, width, height, ctx, tile) => {
+  const data = model.commits;
+  if (!data.ready) return waiting('reading git…');
+  const { total, recent } = data.info;
+  const badge = [];
+  if (data.rebase) {
+    const step = rebaseStep(data.rebase);
+    badge.push(seg(`⟳ rebase ${step}`, 'warn', true));
+  }
+  const titleLine = titleAside(tile, [seg(`${total}`, 'muted')], width, badge);
+  if (!recent.length) return { titleLine, lines: [[seg('none', 'muted')]] };
+  const hot = isHot(data.changedAt, ctx.now);
+  const shown = recent.slice(0, Math.max(0, height));
+  const rows = shown.map((entry, i) => commitRow(entry, ctx, hot && i === 0));
+  return { titleLine, lines: tableLines(rows, width) };
+};
+
+const trackText = (entry) => {
+  if (entry.gone) return 'gone';
+  if (!entry.upstream) return '';
+  const ahead = entry.ahead ? `↑${entry.ahead}` : '';
+  const behind = entry.behind ? `↓${entry.behind}` : '';
+  return ahead + behind || '=';
+};
+
+const branchOrder = (list) =>
+  [...list].sort((left, right) => {
+    if (left.current !== right.current) return left.current ? -1 : 1;
+    return right.at - left.at || left.name.localeCompare(right.name, 'en');
+  });
+
+const blinkTone = (frame) => (Math.abs(frame) % 2 ? 'hot' : 'warn');
+
+const branchRow = (entry, data, ctx) => {
+  const hot = isHot(data.hot.get(entry.name) ?? 0, ctx.now);
+  const tone = hot ? blinkTone(ctx.frame) : 'text';
+  const mark = entry.current ? '▶' : ' ';
+  const name = entry.name.slice(0, NAME_MAX);
+  const track = trackText(entry);
+  const trackTone = entry.behind || entry.gone ? 'error' : 'warn';
+  return [
+    cellSegs([
+      seg(mark, 'sha', true),
+      seg(` ${name}`, tone, entry.current || hot),
+    ]),
+    cell(track, track === '=' ? 'muted' : trackTone),
+    flexCell(entry.subject),
+    ageCell(entry.at, ctx.now),
+  ];
+};
+
+const branchExtras = (data, ctx) => {
+  const rows = [];
+  if (data.rebase) {
+    const step = cell(rebaseStep(data.rebase), 'warn', 'l', true);
+    rows.push([cell('rebase', 'muted'), step]);
+  }
+  const last = data.switches[0];
+  if (last) {
+    rows.push([
+      cell('switched', 'muted'),
+      flexCell(`${last.from} → ${last.to}`),
+      ageCell(last.at, ctx.now),
+    ]);
+  }
+  return rows;
+};
+
+const branchesBlock = (model, width, height, ctx, tile) => {
+  const data = model.branches;
+  if (!data.ready) return waiting('reading git…');
+  const badge = data.rebase ? [seg('⟳', 'warn', true)] : [];
+  const aside = [seg(`${data.list.length}`, 'muted')];
+  const titleLine = titleAside(tile, aside, width, badge);
+  if (!data.list.length) {
+    return { titleLine, lines: [[seg('no branches', 'muted')]] };
+  }
+  const extras = branchExtras(data, ctx);
+  const room = Math.max(1, height - extras.length);
+  const shown = branchOrder(data.list).slice(0, room);
+  const rows = shown.map((entry) => branchRow(entry, data, ctx));
+  const lines = tableLines(rows, width);
+  const fits = extras.slice(0, Math.max(0, height - lines.length));
+  return { titleLine, lines: [...lines, ...tableLines(fits, width)] };
+};
+
+const runIcon = (run, ctx) => {
+  if (run.status === 'running') return [spinner(ctx.frame), 'warn'];
+  return RUN_ICON[run.status] ?? ['?', 'muted'];
+};
+
+const countCell = (value, tone) => {
+  if (typeof value !== 'number') return blankCell();
+  return cell(`${value}`, tone, 'r');
+};
+
+const failTone = (value) => (value ? 'error' : 'muted');
+
+const testMetrics = (done, ok, fail, total) => [
+  countCell(done, 'text'),
+  countCell(ok, ok ? 'add' : 'muted'),
+  countCell(fail, failTone(fail)),
+  countCell(total, 'text'),
+];
+
+const runMetrics = (run) => {
+  const result = run.result;
+  if (result && typeof result.tests === 'number') {
+    const fail = result.failed ?? 0;
+    const ok = result.passed ?? Math.max(0, result.tests - fail);
+    return testMetrics(result.tests, ok, fail, result.tests);
+  }
+  const live = run.status === 'running' && run.source !== 'reslop';
+  if (!live) return [blankCell(), blankCell(), blankCell(), blankCell()];
+  const total = run.expected > 0 ? run.expected : null;
+  return testMetrics(run.done + run.failed, run.done, run.failed, total);
+};
+
+const lintNote = (run) => {
+  const result = run.result;
+  if (!result || typeof result.tests === 'number') return [];
+  const { errors, warnings } = result;
+  if (typeof errors !== 'number') return [];
+  const note = [seg(`  ${errors} err`, failTone(errors))];
+  if (typeof warnings !== 'number') return note;
+  note.push(seg(`  ${warnings} warn`, warnings ? 'warn' : 'muted'));
+  return note;
+};
+
+const durationCell = (run, ctx) => {
+  const running = run.status === 'running';
+  const end = running ? ctx.now : run.endedAt;
+  if (!run.startedAt || !end) return blankCell();
+  return cell(duration(end - run.startedAt), running ? 'warn' : 'muted', 'r');
+};
+
+const named = (icon, tone, name, nameTone) => ({
+  segs: [seg(icon, tone, true), seg(' '), seg(name, nameTone)],
+  align: 'l',
+  flex: true,
+  min: 1,
+});
+
+const runHeader = () => [
+  cell(''),
+  cell('done', 'muted', 'r'),
+  cell('ok', 'muted', 'r'),
+  cell('fail', 'muted', 'r'),
+  cell('total', 'muted', 'r'),
+  cell('duration', 'muted', 'r'),
+];
+
+const runRow = (run, ctx) => {
+  const icon = runIcon(run, ctx);
+  const tone = run.status === 'running' ? 'text' : 'muted';
+  const label = named(icon[0], icon[1], run.name, tone);
+  label.segs.push(...lintNote(run));
+  return [label, ...runMetrics(run), durationCell(run, ctx)];
+};
+
+const runsBlock = (model, width, height, ctx, tile) => {
+  const rows = [];
+  if (model.busy) {
+    rows.push([named(spinner(ctx.frame), 'warn', model.busy, 'warn')]);
+  }
+  for (const run of model.runs) rows.push(runRow(run, ctx));
+  if (!rows.length) {
+    const items = [
+      stat('status', 'idle', 'muted'),
+      stat('usage', 'reslop t -- <command>', 'muted'),
+    ];
+    return { badge: [], lines: tableLines(pairRows(items, 1), width) };
+  }
+  const shown = rows.slice(0, Math.max(1, height));
+  const lines = tableLines([runHeader(), ...shown], width);
+  return {
+    titleLine: captionOver(tile, lines[0]),
+    lines: lines.slice(1),
+  };
+};
+
+module.exports = { commitsBlock, branchesBlock, runsBlock, runMetrics };

package/lib/render/dash-blocks.js

@@ -0,0 +1,245 @@
+'use strict';
+
+const files = require('../files.js');
+const { shortAge } = files;
+const tiles = require('./tiles.js');
+const { seg, barSegments, sparkline, spinner } = tiles;
+const table = require('./dash-table.js');
+const { num, size, delta, waiting, cell, cellSegs, flexCell } = table;
+const { tableLines, pickGroups, labelOf, stat, pairRows } = table;
+const { titleAside, captionOver } = table;
+
+const BAR_W = 6;
+const FOLDER = '📁';
+const MARK_GAP = 1;
+const TREND_LABEL = 'trend  ';
+const UNKNOWN = '…';
+
+const share = (value, total) => (total > 0 ? value / total : 0);
+
+const markCell = (isDir) => cell(isDir ? FOLDER : '');
+
+const nameCell = (key, isDir, hot = false) => {
+  const name = cell(labelOf(key, isDir), hot ? 'warn' : 'sha', 'l', hot);
+  name.gap = MARK_GAP;
+  return name;
+};
+
+const fileName = (key, isDir, hot) => {
+  const name = nameCell(key, isDir, hot);
+  name.flex = true;
+  name.keep = true;
+  return name;
+};
+
+const fileRow = (group, isDir, data) => {
+  const hot = (isDir ? data.hot.dirs : data.hot.exts).has(group.key);
+  const ratio = share(group.bytes, data.total.bytes);
+  return [
+    markCell(isDir),
+    fileName(group.key, isDir, hot),
+    cell(`${group.files}`, 'muted', 'r'),
+    cell(size(group.bytes), 'text', 'r'),
+    cell(num(group.lines), 'muted', 'r'),
+    cellSegs(barSegments(ratio, BAR_W, 'sha')),
+  ];
+};
+
+const filesTotal = (data, ctx) => {
+  const { total } = data;
+  const name = cell('');
+  name.flex = true;
+  name.gap = MARK_GAP;
+  const row = [
+    cell(''),
+    name,
+    cell(`${total.files}`, 'text', 'r', true),
+    cell(size(total.bytes), 'text', 'r', true),
+    cell(num(total.lines), 'text', 'r', true),
+    cell(''),
+  ];
+  const moved = data.delta ? data.delta.lines : 0;
+  const change = delta(moved, ctx.now, data.delta?.at);
+  if (change) row.push(cellSegs([change]));
+  return row;
+};
+
+const filesBlock = (model, width, height, ctx, tile) => {
+  const data = model.files;
+  if (!data.ready) return waiting('scanning…');
+  const picked = pickGroups(data.dirs, data.exts, height - 1);
+  const labels = [
+    cell(''),
+    cell(''),
+    cell('files', 'muted', 'r'),
+    cell('size', 'muted', 'r'),
+    cell('lines', 'muted', 'r'),
+    cell(''),
+  ];
+  const rows = [labels];
+  for (const group of picked.dirs) rows.push(fileRow(group, true, data));
+  for (const group of picked.exts) rows.push(fileRow(group, false, data));
+  rows.push(filesTotal(data, ctx));
+  const lines = tableLines(rows, width);
+  return {
+    titleLine: captionOver(tile, lines[0]),
+    lines: lines.slice(1, -1),
+    footer: lines.at(-1),
+  };
+};
+
+const ratio = (sign, part, total) => `${sign}${part}/${total}`;
+
+const changeCells = (group, bold = false) => [
+  cell(ratio('+', group.stagedAdded, group.added), 'add', 'r', bold),
+  cell(ratio('-', group.stagedRemoved, group.removed), 'del', 'r', bold),
+  cell(`${group.staged}/${group.remaining}`, 'text', 'r', bold),
+  cell(shortAge(group.date), 'muted', 'r'),
+];
+
+const diffRow = (group, isDir) => [
+  markCell(isDir),
+  nameCell(group.key, isDir),
+  ...changeCells(group),
+];
+
+const diffsHeader = (data, ctx) => {
+  const name = cell('');
+  name.gap = MARK_GAP;
+  const row = [cell(''), name, ...changeCells(data.totals, true)];
+  const moved = data.delta ? data.delta.added + data.delta.removed : 0;
+  const change = delta(moved, ctx.now, data.delta?.at);
+  if (change) row[row.length - 1] = cellSegs([change], 'r');
+  return row;
+};
+
+const trendFooter = (data, width) => {
+  const room = width - TREND_LABEL.length;
+  if (data.samples.length < 2 || room < 2) return null;
+  const trend = sparkline(data.samples, room);
+  return [seg(TREND_LABEL, 'muted'), seg(trend, 'trend')];
+};
+
+const diffsBlock = (model, width, height, ctx, tile) => {
+  const data = model.diffs;
+  if (!data.files) {
+    const rows = pairRows([stat('changes', 'working tree clean', 'muted')], 1);
+    return { badge: [], lines: tableLines(rows, width) };
+  }
+  const footer = trendFooter(data, width);
+  const room = footer ? height - 1 : height;
+  const picked = pickGroups(data.dirs, data.exts, room);
+  const rows = [diffsHeader(data, ctx)];
+  for (const group of picked.dirs) rows.push(diffRow(group, true));
+  for (const group of picked.exts) rows.push(diffRow(group, false));
+  const lines = tableLines(rows, width, 2, true);
+  return {
+    titleLine: captionOver(tile, lines[0]),
+    lines: lines.slice(1),
+    footer,
+  };
+};
+
+const countSegs = (label, value) => [
+  seg(`${label}: `, 'muted'),
+  seg(`${value}`, 'text'),
+];
+
+const markSegs = (value, tone, mark) => {
+  if (!value) return [];
+  return [seg('  '), seg(mark), seg(`${value}`, tone, true)];
+};
+
+const npmAside = (data) => {
+  const modules = data.modules;
+  return [
+    ...countSegs('deps', data.deps),
+    seg('  '),
+    ...countSegs('dev', data.dev),
+    seg('  '),
+    ...countSegs('all', modules.count),
+    seg(' (', 'muted'),
+    seg(size(modules.bytes), 'text'),
+    seg(')', 'muted'),
+    ...markSegs(data.audit, 'error', '🚨 '),
+    ...markSegs(data.outdated, 'warn', '⚠️ '),
+  ];
+};
+
+const differs = (left, right) =>
+  left !== UNKNOWN && right !== UNKNOWN && left !== right;
+
+const versionCell = (text, changed, audited) => {
+  const base = changed ? 'warn' : 'muted';
+  const tone = audited && text !== UNKNOWN ? 'error' : base;
+  return cell(text, tone, 'r');
+};
+
+const packageHead = () => {
+  const title = flexCell('');
+  title.keep = true;
+  return [
+    title,
+    cell('current', 'muted', 'r'),
+    cell('wanted', 'muted', 'r'),
+    cell('latest', 'muted', 'r'),
+    cell('size', 'muted', 'r'),
+  ];
+};
+
+const packageRow = (pkg) => {
+  const name = flexCell(pkg.name, pkg.dev ? 'sha' : 'add');
+  name.keep = true;
+  const current = pkg.current || UNKNOWN;
+  const wanted = pkg.wanted || UNKNOWN;
+  const latest = pkg.latest || UNKNOWN;
+  return [
+    name,
+    versionCell(current, differs(current, wanted), pkg.audit),
+    versionCell(wanted, differs(wanted, current), pkg.audit),
+    versionCell(latest, differs(latest, wanted), pkg.audit),
+    cell(size(pkg.bytes), 'muted', 'r'),
+  ];
+};
+
+const npmBlock = (model, width, height, ctx, tile) => {
+  const data = model.npm;
+  if (!data.ready) return waiting('reading package.json…');
+  if (!data.hasManifest) return waiting('no package.json');
+  const badge = data.running ? [seg(spinner(ctx.frame), 'warn', true)] : [];
+  const titleLine = titleAside(tile, npmAside(data), width, badge);
+  const packages = data.modules.packages;
+  const headed = packages.length > 0 && height > 1;
+  const shown = packages.slice(0, Math.max(0, height - (headed ? 1 : 0)));
+  const rows = shown.map(packageRow);
+  if (headed) rows.unshift(packageHead());
+  return { titleLine, lines: tableLines(rows, width) };
+};
+
+const taskName = (title) => {
+  const name = flexCell(title, 'text');
+  name.keep = true;
+  return name;
+};
+
+const taskLine = (title, done, total, bold = false) => [
+  taskName(title),
+  cell(`${done}/${total}`, bold ? 'text' : 'muted', 'r', bold),
+  cellSegs(barSegments(share(done, total), BAR_W)),
+];
+
+const tasksBlock = (model, width, height, ctx, tile) => {
+  const data = model.tasks;
+  const rows = [taskLine('', data.done, data.total, true)];
+  for (const kind of data.kinds) {
+    rows.push(taskLine(kind.title, kind.done, kind.total));
+  }
+  const lines = tableLines(rows, width);
+  const shown = Math.max(0, height);
+  return {
+    titleLine: captionOver(tile, lines[0]),
+    lines: lines.slice(1, 1 + shown),
+  };
+};
+
+module.exports = { filesBlock, diffsBlock, npmBlock, tasksBlock };