reslop 0.2.4 → 0.2.6

package/lib/render/frame.js

@@ -2,7 +2,6 @@
 
 const ansi = require('../ansi.js');
 const select = require('../select.js');
-const { overlayRows } = select;
 const primitives = require('./primitives.js');
 const chrome = require('./chrome.js');
 const files = require('./files.js');
@@ -12,242 +11,189 @@ const notes = require('./notes.js');
 const npm = require('./npm.js');
 const diff = require('./diff.js');
 const unit = require('./unit.js');
+const dashboard = require('./dashboard.js');
 
 const { RESET } = ansi;
-const { LIST_PANES, paintBodyFill, paneResult } = primitives;
+const { overlayRows, markEditorSelection } = select;
+const { isListPane, isTaskView, paintBodyFill, paneResult } = primitives;
 const { paintHeader, paintFooter, footerHits, paintStatusLine } = chrome;
-const { layoutButtons, statusBranchHit, statusChoiceHits } = chrome;
-const { hiddenActions, dimFooterActions, extraFooterActions } = chrome;
+const { footerLayout, statusBranchHit, statusChoiceHits } = chrome;
 const { paintNotePanel, paintBodyTodo } = notes;
-const { paintBodyFiles } = files;
-const { paintBodyBranches } = branches;
-const { paintBodyCommits } = commits;
-const { paintBodyNpm } = npm;
 const { paintBodyDiff } = diff;
-const { paintBodyUnit } = unit;
 
-const bodyKind = (view) => {
-  const pane = view.pane ?? 'diff';
-  if (pane === 'files' || pane === 'branches' || pane === 'commits') {
-    return pane;
-  }
-  if (pane === 'npm') return 'npm';
-  if (pane === 'unit') return 'unit';
-  if (!view.item) return 'empty';
-  if (view.item.origin === 'todo') return 'todo';
-  return 'diff';
+const PANE_BODY = {
+  dashboard: dashboard.paintBodyDashboard,
+  files: files.paintBodyFiles,
+  branches: branches.paintBodyBranches,
+  commits: commits.paintBodyCommits,
+  npm: npm.paintBodyNpm,
+  unit: unit.paintBodyUnit,
+  tasks: paintBodyTodo,
 };
 
 const paintBodyEmpty = () => paneResult();
 
-const BODY_PAINT = {
-  files: paintBodyFiles,
-  branches: paintBodyBranches,
-  commits: paintBodyCommits,
-  npm: paintBodyNpm,
-  empty: paintBodyEmpty,
-  todo: paintBodyTodo,
-  diff: paintBodyDiff,
-  unit: paintBodyUnit,
-};
-
-const paintFrameBody = (view, width, color, bodyH, headerLines) => {
-  const paint = BODY_PAINT[bodyKind(view)];
-  return paint(view, width, color, bodyH, headerLines);
+const bodyPainter = (view) => {
+  if (Object.hasOwn(PANE_BODY, view.pane)) return PANE_BODY[view.pane];
+  if (!view.item) return paintBodyEmpty;
+  return paintBodyDiff;
 };
 
 const frameNotes = (view, width, height, color) => {
   const notesCap = Math.max(0, height - 4);
-  const notesWanted = paintNotePanel(view, width, color, notesCap);
-  const noteRows = notesWanted.rows.slice(0, notesCap);
-  let noteCursor = notesWanted.cursor;
-  if (noteCursor && noteCursor.row >= noteRows.length) noteCursor = null;
-  const chrome = 3 + noteRows.length;
-  const bodyH = Math.max(1, height - chrome);
-  return { notesWanted, noteRows, noteCursor, bodyH };
+  const panel = paintNotePanel(view, width, color, notesCap);
+  const rows = panel.rows.slice(0, notesCap);
+  const inside = panel.cursor && panel.cursor.row < rows.length;
+  const cursor = inside ? panel.cursor : null;
+  const bodyH = Math.max(1, height - 3 - rows.length);
+  return { panel, rows, cursor, bodyH };
 };
 
-const bodyFillKind = (listPane, splitBody) => {
-  if (listPane) return 'files';
-  if (splitBody) return 'split';
-  return 'plain';
+const revealScroll = (owners, focus, height, prefer) => {
+  const first = owners.indexOf(focus);
+  if (first < 0) return prefer;
+  const last = owners.lastIndexOf(focus);
+  const room = Math.max(1, height);
+  let start = Math.min(prefer, first);
+  if (last >= start + room) {
+    start = last - first + 1 <= room ? last - room + 1 : first;
+  }
+  return Math.max(0, Math.min(start, owners.length - room));
 };
 
-const ownerSpan = (owners, focus) => {
-  let first = -1;
-  let last = -1;
-  for (let i = 0; i < owners.length; i++) {
-    if (owners[i] !== focus) continue;
-    if (first < 0) first = i;
-    last = i;
-  }
-  return { first, last };
+const windowY = (win, row) => {
+  const at = row + win.shift - win.scroll;
+  if (at < 0 || at >= win.shown) return -1;
+  return win.headerLines + at + 1;
 };
 
-const revealScroll = (owners, focus, height, prefer) => {
-  const span = ownerSpan(owners, focus);
-  if (span.first < 0) return prefer;
-  const room = Math.max(1, height);
-  let start = prefer;
-  if (span.first < start) start = span.first;
-  if (span.last >= start + room) {
-    const fits = span.last - span.first + 1 <= room;
-    start = fits ? span.last - room + 1 : span.first;
+const mapEditHits = (hits, win) => {
+  const out = [];
+  for (const hit of hits) {
+    const y = windowY(win, hit.row);
+    if (y >= 0) out.push({ ...hit, y });
   }
-  const maxStart = Math.max(0, owners.length - room);
-  if (start > maxStart) start = maxStart;
-  if (start < 0) start = 0;
-  return start;
+  return out;
 };
 
-const mapBodyCursor = (cursor, shift, scroll, headerLines, shown) => {
+const mapBodyCursor = (cursor, win) => {
   if (!cursor) return null;
-  const row = cursor.row + shift;
-  if (row < scroll || row >= scroll + shown) return null;
-  return {
-    x: cursor.x,
-    y: headerLines + (row - scroll) + 1,
-  };
+  const y = windowY(win, cursor.row);
+  if (y < 0) return null;
+  const point = { x: cursor.x, y };
+  if (typeof cursor.scroll === 'number') point.scroll = cursor.scroll;
+  return point;
+};
+
+const bodyFillKind = (listPane, splitBody) => {
+  if (listPane) return 'files';
+  return splitBody ? 'split' : 'plain';
 };
 
-const windowBody = (view, width, color, bodyH, headerLines, paintedBody) => {
-  const sourceBody = paintedBody.body;
-  const sourceOwners = paintedBody.todoOwners;
-  const sourceChecks = paintedBody.todoChecks ?? [];
-  const splitBody = paintedBody.splitBody === true;
-  const pane = view.pane ?? 'diff';
-  const listPane = LIST_PANES.includes(pane);
-  const fillKind = bodyFillKind(listPane, splitBody);
+const windowBody = (view, painted, frame) => {
+  const { width, color, bodyH, headerLines } = frame;
+  const listPane = isListPane(view.pane);
+  const fillKind = bodyFillKind(listPane, painted.splitBody);
   const filler = paintBodyFill(width, color, fillKind);
-  const lead = !listPane && sourceBody.length > 0;
-  const body = new Array(sourceBody.length + (lead ? 1 : 0));
-  let bodyAt = 0;
-  let shift = 0;
-  if (lead) {
-    body[bodyAt++] = filler;
-    shift = 1;
-  }
-  for (let i = 0; i < sourceBody.length; i++) body[bodyAt++] = sourceBody[i];
-  const ownerLead = lead && sourceOwners.length;
-  const todoOwners = new Array(sourceOwners.length + (ownerLead ? 1 : 0));
-  let ownerAt = 0;
-  if (ownerLead) todoOwners[ownerAt++] = null;
-  for (let i = 0; i < sourceOwners.length; i++) {
-    todoOwners[ownerAt++] = sourceOwners[i];
-  }
-  const checkLead = lead && sourceChecks.length;
-  const todoChecks = new Array(sourceChecks.length + (checkLead ? 1 : 0));
-  let checkAt = 0;
-  if (checkLead) todoChecks[checkAt++] = false;
-  for (let i = 0; i < sourceChecks.length; i++) {
-    todoChecks[checkAt++] = sourceChecks[i];
-  }
-  const scrollRaw = view.scroll ?? 0;
+  const shift = !listPane && painted.body.length > 0 ? 1 : 0;
+  const lead = (items, first) =>
+    shift && items.length ? [first, ...items] : items;
+  const body = lead(painted.body, filler);
+  const taskOwners = lead(painted.taskOwners, null);
+  const taskChecks = lead(painted.taskChecks, false);
   const scrollMax = Math.max(0, body.length - bodyH);
-  let scroll = listPane ? 0 : Math.min(scrollRaw, scrollMax);
-  if (view.item && view.item.origin === 'todo') {
-    scroll = revealScroll(todoOwners, view.todoFocus ?? 0, bodyH, scroll);
+  let scroll = listPane ? 0 : Math.min(view.scroll ?? 0, scrollMax);
+  if (isTaskView(view)) {
+    scroll = revealScroll(taskOwners, view.tasksFocus ?? 0, bodyH, scroll);
   }
-  const end = Math.min(body.length, scroll + bodyH);
-  const copied = Math.max(0, end - scroll);
-  const slice = new Array(bodyH);
-  for (let i = 0; i < copied; i++) slice[i] = body[scroll + i];
-  const todoHits = [];
-  for (let i = 0; i < copied; i++) {
-    const owner = todoOwners[scroll + i];
+  const slice = body.slice(scroll, scroll + bodyH);
+  const win = { shift, scroll, shown: slice.length, headerLines };
+  const taskHits = [];
+  for (let i = 0; i < slice.length; i++) {
+    const owner = taskOwners[scroll + i];
     if (owner === undefined || owner === null) continue;
     const y = headerLines + i + 1;
-    if (todoChecks[scroll + i]) {
-      todoHits.push({ y, cursor: owner, x0: 1, x1: 4, check: true });
+    if (taskChecks[scroll + i]) {
+      taskHits.push({ y, cursor: owner, x0: 1, x1: 4, check: true });
     }
-    todoHits.push({ y, cursor: owner });
+    taskHits.push({ y, cursor: owner });
   }
-  const cursor = mapBodyCursor(
-    paintedBody.cursor,
-    shift,
+  while (slice.length < bodyH) slice.push(filler);
+  return {
+    slice,
     scroll,
-    headerLines,
-    copied,
-  );
-  for (let i = copied; i < bodyH; i++) slice[i] = filler;
-  const listScroll = paintedBody.listScroll ?? 0;
-  const fileHits = paintedBody.fileHits;
-  return { slice, scroll, scrollMax, listScroll, todoHits, fileHits, cursor };
+    scrollMax,
+    listScroll: painted.listScroll,
+    taskHits,
+    fileHits: painted.fileHits,
+    editHits: mapEditHits(painted.editHits, win),
+    cursor: mapBodyCursor(painted.cursor, win),
+  };
 };
 
-const notePointerHits = (notesWanted, noteRows, noteCursor, bodyH) => {
-  let cursor = null;
-  if (noteCursor) {
-    cursor = { x: noteCursor.x, y: 2 + bodyH + noteCursor.row };
-  }
+const notePointerHits = (notes, bodyH) => {
+  const { panel, rows, cursor } = notes;
+  const top = 2 + bodyH;
   const templateHits = [];
-  for (const hit of notesWanted.templateHits ?? []) {
-    if (hit.row >= noteRows.length) continue;
-    templateHits.push({ y: 2 + bodyH + hit.row, cursor: hit.cursor });
+  for (const hit of panel.templateHits) {
+    if (hit.row < rows.length) {
+      templateHits.push({ y: top + hit.row, cursor: hit.cursor });
+    }
   }
-  return { cursor, templateHits };
-};
-
-const stackFrame = (view, width, color, rows, layout, windowed, notes) => {
-  for (const row of windowed.slice) rows.push(row);
-  for (const row of notes.noteRows) rows.push(row);
-  const status = view.status ?? '';
-  rows.push(paintStatusLine(view, status, width, color));
-  rows.push(paintFooter(view, layout, width, color));
-  return overlayRows(rows, view.selection);
+  const editHits = [];
+  for (const hit of panel.editHits) {
+    if (hit.row < rows.length) editHits.push({ ...hit, y: top + hit.row });
+  }
+  const point = cursor ? { x: cursor.x, y: top + cursor.row } : null;
+  return { cursor: point, templateHits, editHits };
 };
 
 const renderFrame = (view, options = {}) => {
   const width = Math.max(20, options.width ?? 80);
   const height = Math.max(6, options.height ?? 24);
   const color = options.color ?? true;
-  const rows = [paintHeader(view, width, color)];
-  const extra = extraFooterActions(view);
-  const hidden = hiddenActions(view);
-  const dimmed = dimFooterActions(view);
-  const layout = layoutButtons(width, false, hidden, extra, dimmed);
+  const headerLines = 1;
+  const layout = footerLayout(view, width);
   const notes = frameNotes(view, width, height, color);
-  const headerLines = rows.length;
-  const bodyH = notes.bodyH;
-  const paintedBody = paintFrameBody(view, width, color, bodyH, headerLines);
-  const windowed = windowBody(
-    view,
-    width,
-    color,
-    bodyH,
-    headerLines,
-    paintedBody,
+  const { bodyH } = notes;
+  const paint = bodyPainter(view);
+  const painted = paint(view, width, color, bodyH, headerLines);
+  const frame = { width, color, bodyH, headerLines };
+  const windowed = windowBody(view, painted, frame);
+  const rows = overlayRows(
+    [
+      paintHeader(view, width, color),
+      ...windowed.slice,
+      ...notes.rows,
+      paintStatusLine(view, view.status ?? '', width, color),
+      paintFooter(view, layout, width, color),
+    ],
+    view.selection,
   );
-  const painted = stackFrame(view, width, color, rows, layout, windowed, notes);
-  const text = painted.map((row) => (color ? row + RESET : row)).join('\n');
-  const hits = notePointerHits(
-    notes.notesWanted,
-    notes.noteRows,
-    notes.noteCursor,
-    bodyH,
-  );
-  const statusY = painted.length - 1;
+  const hits = notePointerHits(notes, bodyH);
+  const statusY = rows.length - 1;
   const branchHit = statusBranchHit(view, width, statusY);
   const statusHits = branchHit ? [branchHit] : statusChoiceHits(view, statusY);
-  const { fileHits, todoHits, scroll, scrollMax, listScroll } = windowed;
-  const { templateHits } = hits;
-  const footerY = painted.length;
+  const editHits = [...windowed.editHits, ...hits.editHits];
+  const shown = markEditorSelection(rows, view, editHits, color);
+  const text = shown.map((row) => (color ? row + RESET : row)).join('\n');
   return {
     text,
-    rows: painted,
+    rows: shown,
     buttons: footerHits(view, layout),
-    fileHits,
-    todoHits,
-    templateHits,
+    fileHits: windowed.fileHits,
+    taskHits: windowed.taskHits,
+    templateHits: hits.templateHits,
+    editHits,
     statusHits,
-    footerY,
-    height: footerY,
-    scroll,
-    scrollMax,
-    listScroll,
+    footerY: rows.length,
+    height: rows.length,
+    scroll: windowed.scroll,
+    scrollMax: windowed.scrollMax,
+    listScroll: windowed.listScroll,
     cursor: hits.cursor ?? windowed.cursor,
     bodyH,
   };
 };
 
-module.exports = { BODY_PAINT, renderFrame };
+module.exports = { renderFrame };