reslop 0.1.9 → 0.2.1

package/lib/render/notes.js

@@ -11,7 +11,7 @@ const { THEME, visibleWidth, truncateVisible, seq, EL, RESET, BOLD } = ansi;
 const { paintBar, paintCheckBar, windowRows } = primitives;
 const { LIST_PANES, CHECK_LEAD, paneResult } = primitives;
 
-const NOTE_COMPOSE = ['feedback', 'commit'];
+const NOTE_COMPOSE = ['feedback'];
 const INPUT_MAX = 4;
 const NOTE_MAX = 4;
 const NOTE_PAD = 1;
@@ -36,10 +36,11 @@ const wrapTodoItem = (text, inner) => {
   const bodyWidth = Math.max(1, inner - lead);
   const hang = ' '.repeat(lead);
   const wrapped = wrapMultiline(body, bodyWidth);
-  const lines = [];
-  for (let i = 0; i < wrapped.length; i++) {
+  const { length } = wrapped;
+  const lines = new Array(length);
+  for (let i = 0; i < length; i++) {
     const prefix = i === 0 ? mark : hang;
-    lines.push(`${prefix}${wrapped[i]}`);
+    lines[i] = `${prefix}${wrapped[i]}`;
   }
   return lines;
 };
@@ -56,6 +57,7 @@ const paintTodoList = (texts, focus, width, color, edit) => {
   const inner = todoInnerWidth(width);
   const rows = [];
   const owners = [];
+  const checks = [];
   let cursor = null;
   for (let i = 0; i < texts.length; i++) {
     const selected = i === focus;
@@ -64,14 +66,22 @@ const paintTodoList = (texts, focus, width, color, edit) => {
     const text = texts[i];
     const wrapped = wrapTodoItem(text, inner);
     const rowStart = rows.length;
-    for (const line of wrapped) {
-      rows.push(paintCheckBar(` ${line}`, width, fgRgb, bgRgb, color));
+    for (let line = 0; line < wrapped.length; line++) {
+      const painted = paintCheckBar(
+        ` ${wrapped[line]}`,
+        width,
+        fgRgb,
+        bgRgb,
+        color,
+      );
+      rows.push(painted);
       owners.push(i);
+      checks.push(line === 0);
     }
     if (!edit || !selected) continue;
     cursor = todoCursor(text, edit, inner, rowStart);
   }
-  return { rows, owners, cursor };
+  return { rows, owners, checks, cursor };
 };
 
 const noteInnerWidth = (width) => Math.max(1, width - NOTE_PAD * 2);
@@ -183,13 +193,21 @@ const paintBodyTodo = (view, width, color) => {
   const caption = paintTodoCaption(width, color);
   const body = [caption, ...painted.rows];
   const todoOwners = [null, ...painted.owners];
+  const todoChecks = [false, ...painted.checks];
   let cursor = null;
   if (painted.cursor) {
     cursor = { x: painted.cursor.x, row: painted.cursor.row + 1 };
   }
   const fileHits = [];
   const splitBody = false;
-  return paneResult({ body, fileHits, todoOwners, cursor, splitBody });
+  return paneResult({
+    body,
+    fileHits,
+    todoOwners,
+    todoChecks,
+    cursor,
+    splitBody,
+  });
 };
 
 module.exports = {

package/lib/render/primitives.js

@@ -104,6 +104,13 @@ const listWindowStart = (focus, offset, listH, count) => {
   return start;
 };
 
+const extraIdx = (extraRow, cursor, count) => {
+  if (!extraRow) return -1;
+  if (extraRow.at === 'start') return 0;
+  if (extraRow.at === 'replace') return extraRow.index ?? cursor;
+  return count;
+};
+
 const paintCursorList = (
   items,
   cursor,
@@ -112,15 +119,16 @@ const paintCursorList = (
   bodyH,
   headerLines,
   paintRow,
-  tail,
+  extraRow,
   offset = 0,
 ) => {
   const pad = bodyH >= FILE_LIST_PAD * 2 + 1 ? FILE_LIST_PAD : 0;
   const listH = bodyH - pad * 2;
-  const extra = tail ? 1 : 0;
+  const inserting = extraRow && extraRow.at === 'start';
+  const extra = extraRow && extraRow.at !== 'replace' ? 1 : 0;
   const count = items.length + extra;
-  const last = count - 1;
-  const focus = extra ? last : cursor;
+  const extraAt = extraIdx(extraRow, cursor, items.length);
+  const focus = extraRow ? extraAt : cursor;
   const start = listWindowStart(focus, offset, listH, count);
   const blank = paintBodyFill(width, color, 'files');
   const body = [];
@@ -129,19 +137,20 @@ const paintCursorList = (
   if (pad) body.push(blank);
   for (let i = 0; i < listH; i++) {
     const idx = start + i;
-    if (tail && idx === items.length) {
-      body.push(tail.row);
-      if (tail.cursor) {
-        textCursor = { x: tail.cursor.x, row: body.length - 1 };
+    if (extraRow && idx === extraAt) {
+      body.push(extraRow.row);
+      if (extraRow.cursor) {
+        textCursor = { x: extraRow.cursor.x, row: body.length - 1 };
       }
       continue;
     }
-    const entry = items[idx];
+    const itemIdx = inserting ? idx - 1 : idx;
+    const entry = items[itemIdx];
     if (!entry) break;
-    const selected = extra ? false : idx === cursor;
+    const selected = extraRow ? false : itemIdx === cursor;
     body.push(paintRow(entry, width, color, selected));
     const y = headerLines + pad + i + 1;
-    fileHits.push({ y, cursor: idx });
+    fileHits.push({ y, cursor: itemIdx });
   }
   if (pad) body.push(blank);
   return { body, fileHits, cursor: textCursor, offset: start };
@@ -171,16 +180,94 @@ const paintBracketName = (label, nameFg, wrapFg, bgRgb, color, nameBold) => {
   );
 };
 
+const paintListEdit = (compose, width, color, edgeW) => {
+  const inner = Math.max(1, width - edgeW);
+  const prefix = ` ${FILE_MARK} `;
+  const prefixW = visibleWidth(prefix);
+  const rest = Math.max(1, inner - prefixW);
+  const text = `${compose.text ?? ''}`.replaceAll('\n', ' ');
+  const label = `[${text}]`;
+  const clipped = truncateVisible(label, rest);
+  const pad = Math.max(0, rest - visibleWidth(clipped));
+  const left = `${prefix}${clipped}${' '.repeat(pad)}`;
+  const fgRgb = THEME.chromeFg;
+  const bgRgb = THEME.buttonBg;
+  const edge = fill(edgeW, fgRgb, THEME.ctxBg, color);
+  let row = `${left}${edge}`;
+  if (color) {
+    const gap = ' '.repeat(pad);
+    row = `${seq(fgRgb, bgRgb)}${EL}`;
+    row += paint(prefix, fgRgb, bgRgb, color);
+    row += paintBracketName(
+      clipped,
+      THEME.buttonHotFg,
+      THEME.mutedFg,
+      bgRgb,
+      color,
+    );
+    row += paint(gap, fgRgb, bgRgb, color);
+    row += edge;
+  }
+  const col = Math.min((compose.cursor ?? 0) + 1, visibleWidth(clipped));
+  return { row, cursor: { x: prefixW + col + 1 } };
+};
+
 const paneResult = (fields) => ({
   body: fields.body,
   fileHits: fields.fileHits,
   todoOwners: fields.todoOwners,
+  todoChecks: fields.todoChecks ?? [],
   cursor: fields.cursor ?? null,
   splitBody: fields.splitBody === true,
   listScroll: fields.listScroll ?? 0,
 });
 
+const measureColumns = (entries, rowFields, align) => {
+  const keys = Object.keys(align);
+  const widths = Object.fromEntries(keys.map((key) => [key, 0]));
+  for (const entry of entries) {
+    const fields = rowFields(entry);
+    for (const key of keys) {
+      widths[key] = Math.max(widths[key], visibleWidth(fields[key]));
+    }
+  }
+  return widths;
+};
+
+const padColumns = (fields, widths, align) => {
+  const parts = {};
+  for (const key of Object.keys(align)) {
+    const width = widths?.[key] ?? visibleWidth(fields[key]);
+    parts[key] = padVisible(fields[key], width, align[key]);
+  }
+  return parts;
+};
+
+const columnGap = (key) => (key === 'date' ? '   ' : '  ');
+
+const joinColumns = (parts, widths) => {
+  let text = '';
+  for (const key of Object.keys(parts)) {
+    if (widths[key]) text += columnGap(key) + parts[key];
+  }
+  return text;
+};
+
+const paintColumns = (parts, widths, fgRgb, bgRgb, color, tones) => {
+  let text = '';
+  for (const key of Object.keys(parts)) {
+    if (!widths[key]) continue;
+    text += paint(columnGap(key), fgRgb, bgRgb, color);
+    text += paint(parts[key], tones[key] ?? fgRgb, bgRgb, color);
+  }
+  return text;
+};
+
 module.exports = {
+  measureColumns,
+  padColumns,
+  joinColumns,
+  paintColumns,
   GUTTER_W,
   FILE_MARK,
   LIST_PANES,
@@ -194,6 +281,7 @@ module.exports = {
   paintBodyFill,
   windowRows,
   paintCursorList,
+  paintListEdit,
   branchLabel,
   paintBracketName,
   paneResult,

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

@@ -1,15 +1,15 @@
 'use strict';
 
-const chrome = require('./render/chrome.js');
-const notes = require('./render/notes.js');
-const diff = require('./render/diff.js');
-const present = require('./render/present.js');
-const { renderFrame } = require('./render/frame.js');
+const chrome = require('./chrome.js');
+const notes = require('./notes.js');
+const diff = require('./diff.js');
+const present = require('./present.js');
+const { renderFrame } = require('./frame.js');
 
 const { QUIT_PROMPT, PUSH_PROMPT } = chrome;
 const { updatePrompt, dropPrompt } = chrome;
 const { formatBusyStatus, headerText, layoutButtons } = chrome;
-const { DEL_CHAR_BG, ADD_CHAR_BG, paintDiffLine, codeInnerWidth } = diff;
+const { delCharBg, addCharBg, paintDiffLine, codeInnerWidth } = diff;
 const { todoInnerWidth, todoBodyWidth, noteInnerWidth } = notes;
 const { presentCursor, presentRows } = present;
 
@@ -18,8 +18,8 @@ module.exports = {
   PUSH_PROMPT,
   updatePrompt,
   dropPrompt,
-  DEL_CHAR_BG,
-  ADD_CHAR_BG,
+  delCharBg,
+  addCharBg,
   paintDiffLine,
   headerText,
   layoutButtons,

package/lib/render/unit.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const { detectLang } = require('../detect.js');
+const primitives = require('./primitives.js');
+const diff = require('./diff.js');
+
+const { paneResult } = primitives;
+const { paintDiffLine, codeCursorInRows } = diff;
+const { sameHunk } = require('../diff/diff.js');
+
+const paintBodyUnit = (view, width, color) => {
+  const lines = view.unitLines ?? [];
+  const item = view.item;
+  const lang = detectLang(view.reviewPath ?? '');
+  const overlay = view.codeOverlay;
+  const editing = view.mode === 'compose' && overlay;
+  const { length } = lines;
+  const body = new Array(length);
+  for (let i = 0; i < length; i++) {
+    const line = lines[i];
+    const isBlock = item && sameHunk(line.item, item);
+    const row = { ...line };
+    if (editing) {
+      row.mark = ' ';
+    } else if ((row.type === 'add' || row.type === 'del') && !isBlock) {
+      row.mark = ' ';
+    }
+    body[i] = paintDiffLine(row, width, color, row.origin, lang);
+  }
+  const edit = overlay ? overlay.cursor : null;
+  const cursor = codeCursorInRows(lines, false, width, edit);
+  return paneResult({
+    body,
+    fileHits: [],
+    todoOwners: [],
+    cursor,
+    splitBody: false,
+  });
+};
+
+module.exports = { paintBodyUnit };

package/lib/review-merge.js

@@ -0,0 +1,270 @@
+'use strict';
+
+const { TODO_FILE } = require('./files.js');
+
+const flatText = (text) => `${text ?? ''}`.trim().replace(/\n/g, ' ');
+
+const snapTodo = (todo) => ({
+  file: todo.file ?? '',
+  text: flatText(todo.text),
+  done: todo.done === true,
+});
+
+const snapList = (todos) => {
+  const list = [];
+  for (const todo of todos ?? []) {
+    const snap = snapTodo(todo);
+    if (!snap.text) continue;
+    list.push(snap);
+  }
+  return list;
+};
+
+const copyMap = (map) => {
+  const next = new Map();
+  if (!map) return next;
+  for (const [key, note] of map) next.set(key, { ...note });
+  return next;
+};
+
+const snapshotSide = (store) => ({
+  status: store.status,
+  todos: snapList(store.todos),
+  feedback: copyMap(store.feedback),
+  code: copyMap(store.code),
+});
+
+const captureBaseline = (store) => {
+  store.baseline = snapshotSide(store);
+};
+
+const claim = (list, used, text, read) => {
+  for (let i = 0; i < list.length; i++) {
+    if (used[i]) continue;
+    if (read(list[i]) !== text) continue;
+    used[i] = true;
+    return i;
+  }
+  return -1;
+};
+
+const pickDone = (baseDone, ourDone, theirDone) => {
+  if (ourDone === theirDone) return ourDone;
+  if (theirDone === baseDone) return ourDone;
+  if (ourDone === baseDone) return theirDone;
+  return ourDone;
+};
+
+const withDone = (todo, done) => {
+  if (todo.done === done) return todo;
+  return { id: todo.id, file: todo.file, text: todo.text, done };
+};
+
+const liveText = (todo) => flatText(todo.text);
+
+const snapText = (snap) => snap.text;
+
+const flags = (n) => new Array(n).fill(false);
+
+const adoptTodo = (store, snap) => {
+  const id = store.nextTodoId;
+  store.nextTodoId += 1;
+  const file = snap.file || TODO_FILE;
+  return { id, file, text: snap.text, done: snap.done };
+};
+
+const findMerged = (merged, alias, text) => {
+  const linked = alias.get(text);
+  if (linked) {
+    const at = merged.indexOf(linked);
+    if (at >= 0) return at;
+  }
+  for (let i = 0; i < merged.length; i++) {
+    if (liveText(merged[i]) === text) return i;
+  }
+  return -1;
+};
+
+const insertTheir = (store, merged, theirs, theirKeep, alias) => {
+  for (let i = 0; i < theirs.length; i++) {
+    if (!theirKeep[i]) continue;
+    let at = merged.length;
+    let placed = false;
+    for (let j = i - 1; j >= 0 && !placed; j--) {
+      const prev = findMerged(merged, alias, theirs[j].text);
+      if (prev < 0) continue;
+      at = prev + 1;
+      placed = true;
+    }
+    for (let j = i + 1; j < theirs.length && !placed; j++) {
+      const next = findMerged(merged, alias, theirs[j].text);
+      if (next < 0) continue;
+      at = next;
+      placed = true;
+    }
+    const item = adoptTodo(store, theirs[i]);
+    merged.splice(at, 0, item);
+    alias.set(theirs[i].text, item);
+  }
+  return merged;
+};
+
+const keepOurs = (ours, kept, alias, index, text) => {
+  kept[index] = true;
+  alias.set(text, ours[index]);
+};
+
+const mergeBaseTodo = (
+  base,
+  ours,
+  theirs,
+  used,
+  kept,
+  dropped,
+  theirKeep,
+  alias,
+) => {
+  const text = base.text;
+  const oi = claim(ours, used.ours, text, liveText);
+  const ti = claim(theirs, used.theirs, text, snapText);
+  if (oi >= 0 && ti >= 0) {
+    const done = pickDone(base.done, ours[oi].done === true, theirs[ti].done);
+    ours[oi] = withDone(ours[oi], done);
+    keepOurs(ours, kept, alias, oi, text);
+    return;
+  }
+  if (oi >= 0) {
+    if (ours[oi].done === base.done) {
+      dropped[oi] = true;
+      return;
+    }
+    keepOurs(ours, kept, alias, oi, text);
+    return;
+  }
+  if (ti >= 0 && theirs[ti].done !== base.done) theirKeep[ti] = true;
+};
+
+const replaceTodo = (todo, snap) => ({
+  id: todo.id,
+  file: todo.file,
+  text: snap.text,
+  done: snap.done,
+});
+
+const fillGaps = (merged, gaps, theirs, theirKeep, alias) => {
+  let filled = 0;
+  for (let i = 0; i < theirs.length && filled < gaps.length; i++) {
+    if (!theirKeep[i]) continue;
+    const gap = gaps[filled];
+    const item = replaceTodo(gap.todo, theirs[i]);
+    merged.splice(gap.at, 0, item);
+    alias.set(theirs[i].text, item);
+    theirKeep[i] = false;
+    filled += 1;
+  }
+};
+
+const mergeFreshTodo = (ours, theirs, used, kept, alias, index) => {
+  const text = liveText(ours[index]);
+  const ti = claim(theirs, used.theirs, text, snapText);
+  if (ti < 0) {
+    kept[index] = true;
+    return;
+  }
+  const done = ours[index].done === true || theirs[ti].done === true;
+  ours[index] = withDone(ours[index], done);
+  keepOurs(ours, kept, alias, index, text);
+};
+
+const mergeTodos = (store, base, theirs) => {
+  const ours = [];
+  for (const todo of store.todos) {
+    if (!liveText(todo)) continue;
+    ours.push(todo);
+  }
+  const used = { ours: flags(ours.length), theirs: flags(theirs.length) };
+  const kept = flags(ours.length);
+  const dropped = flags(ours.length);
+  const theirKeep = flags(theirs.length);
+  const alias = new Map();
+  for (const item of base) {
+    mergeBaseTodo(item, ours, theirs, used, kept, dropped, theirKeep, alias);
+  }
+  for (let i = 0; i < ours.length; i++) {
+    if (used.ours[i]) continue;
+    mergeFreshTodo(ours, theirs, used, kept, alias, i);
+  }
+  for (let i = 0; i < theirs.length; i++) {
+    if (!used.theirs[i]) theirKeep[i] = true;
+  }
+  const merged = [];
+  const gaps = [];
+  let cursor = 0;
+  for (let i = 0; i < ours.length; i++) {
+    if (kept[i]) {
+      merged.push(ours[i]);
+      cursor += 1;
+      continue;
+    }
+    if (!dropped[i]) continue;
+    gaps.push({ at: cursor, todo: ours[i] });
+    cursor += 1;
+  }
+  fillGaps(merged, gaps, theirs, theirKeep, alias);
+  store.todos = insertTheir(store, merged, theirs, theirKeep, alias);
+};
+
+const sameNote = (left, right) =>
+  left.text === right.text && !!left.done === !!right.done;
+
+const cloneNote = (note, done) => {
+  if (!!note.done === done) return note;
+  return { ...note, done };
+};
+
+const pickNote = (ours, base, theirs) => {
+  if (ours && theirs && ours.text === theirs.text) {
+    const baseDone = base ? base.done === true : ours.done === true;
+    const done = pickDone(baseDone, ours.done === true, theirs.done === true);
+    return cloneNote(ours, done);
+  }
+  if (!base) return ours || theirs || null;
+  if (!ours) {
+    if (!theirs || sameNote(theirs, base)) return null;
+    return theirs;
+  }
+  if (!theirs) {
+    if (sameNote(ours, base)) return null;
+    return ours;
+  }
+  if (sameNote(theirs, base)) return ours;
+  if (sameNote(ours, base)) return theirs;
+  return ours;
+};
+
+const mergeMap = (ours, base, theirs) => {
+  const keys = new Set();
+  for (const key of ours.keys()) keys.add(key);
+  for (const key of base.keys()) keys.add(key);
+  for (const key of theirs.keys()) keys.add(key);
+  for (const key of keys) {
+    const next = pickNote(ours.get(key), base.get(key), theirs.get(key));
+    if (!next) ours.delete(key);
+    else ours.set(key, next);
+  }
+};
+
+const mergeReview = (store, disk) => {
+  const base = store.baseline;
+  const baseTodos = base ? base.todos : [];
+  const baseStatus = base ? base.status : store.status;
+  mergeTodos(store, baseTodos, snapList(disk.todos));
+  const feedback = base ? base.feedback : new Map();
+  const code = base ? base.code : new Map();
+  mergeMap(store.feedback, feedback, disk.feedback);
+  mergeMap(store.code, code, disk.code);
+  if (store.status === baseStatus && disk.status) store.status = disk.status;
+  store.baseline = snapshotSide(disk);
+};
+
+module.exports = { captureBaseline, mergeReview };