reslop 0.2.4 → 0.2.6

package/lib/remote.js

@@ -15,8 +15,6 @@ const RETRY_ATTEMPTS = 3;
 const RETRY_DELAY_MS = 200;
 const TRANSIENT_STATUS = [429, 502, 503, 504];
 
-const isRecord = isHashObject;
-
 const abortError = (signal) => {
   if (signal && signal.reason !== undefined) return signal.reason;
   const error = new Error('This operation was aborted');
@@ -26,110 +24,142 @@ const abortError = (signal) => {
 
 const isAbortError = (error, signal) => {
   if (signal && signal.aborted) return true;
-  if (!error || typeof error !== 'object') return false;
-  if (error.name === 'AbortError') return true;
-  if (error.code === 'ABORT') return true;
-  return false;
+  return error?.name === 'AbortError' || error?.code === 'ABORT';
 };
 
 const throwIfAborted = (signal) => {
   if (signal && signal.aborted) throw abortError(signal);
 };
 
-const wait = async (ms, abortSignal) => {
+const wait = async (ms, signal) => {
   try {
-    await delay(ms, abortSignal);
+    await delay(ms, signal);
   } catch (error) {
-    throwIfAborted(abortSignal);
+    throwIfAborted(signal);
     throw error;
   }
 };
 
-const createTransport = (deps = {}) => {
-  const fetchImpl = deps.fetch;
-  const signal = deps.signal;
+class RemoteClient {
+  constructor(options) {
+    this.name = options.name;
+    this.subject = options.subject;
+    this.prefix = options.name.toUpperCase();
+    this.headers = options.headers;
+    this.nextPage = options.nextPage;
+    this.errorFields = options.errorFields ?? ['message'];
+    this.limitStatus = options.limitStatus ?? 0;
+  }
+
+  error(code, message, extra = {}) {
+    const fields = { code: `${this.prefix}_${code}`, ...extra };
+    return Object.assign(new Error(message), fields);
+  }
 
-  const retry = async (run, options = {}) => {
-    const attempts = options.attempts ?? RETRY_ATTEMPTS;
-    const delayMs = options.delayMs ?? RETRY_DELAY_MS;
-    const isRetryable = options.isRetryable;
-    for (let i = 0; ; i++) {
+  parseJson(text, label, validate = isHashObject) {
+    const data = jsonParse(text ?? '');
+    if (validate(data)) return data;
+    throw this.error('PARSE', `${this.name} API: invalid ${label}`);
+  }
+
+  httpError(status, body, token) {
+    const { name, prefix } = this;
+    const text = `${body ?? ''}`.trim();
+    const parsed = jsonParse(text);
+    const fields = this.errorFields;
+    const field = fields.find((key) => typeof parsed?.[key] === 'string');
+    const message =
+      isHashObject(parsed) && field ? parsed[field] : oneLine(text);
+    if (status === 404) {
+      const hint = token
+        ? ''
+        : ` (set ${prefix}_TOKEN for private repositories)`;
+      const notFound = `${name} ${this.subject} not found${hint}`;
+      return this.error('NOT_FOUND', notFound, { status });
+    }
+    if (status === 401) {
+      return this.error('AUTH', `${name} authentication failed`, { status });
+    }
+    const rateLimit = status === 403 && /rate limit/i.test(message);
+    if (rateLimit || status === this.limitStatus) {
+      const limited = `${name} API rate limit exceeded`;
+      return this.error('RATE_LIMIT', limited, { status });
+    }
+    const detail = message ? `: ${oneLine(message)}` : ` HTTP ${status}`;
+    return this.error('HTTP', `${name} API${detail}`, { status });
+  }
+
+  isRetryable(error) {
+    if (error.code === `${this.prefix}_NETWORK`) return true;
+    return TRANSIENT_STATUS.includes(error.status);
+  }
+
+  async fetchPage(url, options) {
+    const { signal, token = '' } = options;
+    const headers = this.headers(token, options.accept);
+    if (options.contentType) headers['Content-Type'] = options.contentType;
+    const init = { method: options.method || 'GET', headers };
+    if (options.body !== undefined) init.body = options.body;
+    if (signal) init.signal = signal;
+    let response;
+    try {
+      response = await options.fetch(url, init);
+    } catch (cause) {
+      if (isAbortError(cause, signal)) throw cause;
+      const detail = oneLine(cause && cause.message);
+      const suffix = detail ? `: ${detail}` : '';
+      const message = `${this.name} request failed${suffix}`;
+      throw this.error('NETWORK', message, { cause });
+    }
+    const text = await response.text();
+    if (!response.ok) throw this.httpError(response.status, text, token);
+    return { body: text, headers: response.headers };
+  }
+
+  async request(url, options) {
+    const { signal, retry = {} } = options;
+    throwIfAborted(signal);
+    if (typeof options.fetch !== 'function') {
+      throw this.error('FETCH', 'fetch is not available');
+    }
+    const attempts = retry.attempts ?? RETRY_ATTEMPTS;
+    const delayMs = retry.delayMs ?? RETRY_DELAY_MS;
+    for (let attempt = 1; ; attempt++) {
       try {
-        return await run();
+        return await this.fetchPage(url, options);
       } catch (error) {
         if (isAbortError(error, signal)) throw error;
-        const isLast = i === attempts - 1;
-        if (isLast || !isRetryable(error)) throw error;
-        throwIfAborted(signal);
-        await wait(delayMs * (i + 1), signal);
+        if (attempt >= attempts || !this.isRetryable(error)) throw error;
+        await wait(delayMs * attempt, signal);
       }
     }
-  };
-
-  const request = async (url, options = {}) => {
-    throwIfAborted(signal);
-    if (typeof fetchImpl !== 'function') {
-      throw options.missingFetch();
-    }
-    const headers = options.headers;
-    const method = options.method || 'GET';
-    const body = options.body;
-    const wrapNetwork = options.wrapNetwork;
-    const toHttpError = options.toHttpError;
-    const retryOpts = options.retry ?? {};
-    return retry(
-      async () => {
-        let response;
-        try {
-          const init = { method, headers };
-          if (body !== undefined) init.body = body;
-          if (signal) init.signal = signal;
-          response = await fetchImpl(url, init);
-        } catch (error) {
-          if (isAbortError(error, signal)) throw error;
-          throw wrapNetwork(error);
-        }
-        const text = await response.text();
-        if (!response.ok) throw toHttpError(response.status, text);
-        return { body: text, headers: response.headers };
-      },
-      { ...retryOpts, isRetryable: options.isRetryable },
-    );
-  };
+  }
 
-  const listPages = async (url, options = {}) => {
+  async list(url, options) {
     const items = [];
     let next = url;
-    const parsePage = options.parsePage;
-    const nextPage = options.nextPage;
     while (next) {
-      const page = await request(next, options);
-      const entries = parsePage(page.body);
-      for (const entry of entries) items.push(entry);
-      next = nextPage(page.headers, next);
+      const page = await this.request(next, { ...options, method: 'GET' });
+      const entries = this.parseJson(page.body, 'list payload', Array.isArray);
+      items.push(...entries);
+      next = this.nextPage(page.headers, next);
     }
     return items;
-  };
-
-  return { retry, request, listPages };
-};
+  }
+}
 
 const headerValue = (headers, name) => {
   if (!headers) return '';
-  if (typeof headers.get === 'function') {
-    return headers.get(name) || '';
-  }
+  if (typeof headers.get === 'function') return headers.get(name) || '';
   const wanted = name.toLowerCase();
   for (const key of Object.keys(headers)) {
-    const value = headers[key];
-    if (key.toLowerCase() === wanted) return `${value}`;
+    if (key.toLowerCase() === wanted) return `${headers[key]}`;
   }
   return '';
 };
 
 const parseLinkNext = (headers) => {
   const link = headerValue(headers, 'link');
-  if (!link) return '';
   for (const part of link.split(',')) {
     const match = /<([^>]+)>\s*;\s*rel="?next"?/i.exec(part.trim());
     if (match) return match[1];
@@ -153,106 +183,24 @@ const listUrl = (base) => {
   return url.toString();
 };
 
-const createClient = ({ name, subject, headers, nextPage }) => {
-  const prefix = name.toUpperCase();
-  const error = (code, message, extra = {}) =>
-    Object.assign(new Error(message), { code: `${prefix}_${code}`, ...extra });
-
-  const parseJson = (text, label, validate = isHashObject) => {
-    const data = jsonParse(text ?? '');
-    if (!validate(data)) throw error('PARSE', `${name} API: invalid ${label}`);
-    return data;
-  };
-
-  const httpError = (status, body, token) => {
-    const text = `${body ?? ''}`.trim();
-    const parsed = jsonParse(text);
-    const fields = name === 'GitLab' ? ['message', 'error'] : ['message'];
-    const field = fields.find((key) => typeof parsed?.[key] === 'string');
-    const message =
-      isHashObject(parsed) && field ? parsed[field] : oneLine(text);
-    if (status === 404) {
-      const hint = token
-        ? ''
-        : ` (set ${prefix}_TOKEN for private repositories)`;
-      return error('NOT_FOUND', `${name} ${subject} not found${hint}`, {
-        status,
-      });
-    }
-    if (status === 401) {
-      return error('AUTH', `${name} authentication failed`, { status });
-    }
-    const rateLimit = status === 403 && /rate limit/i.test(message);
-    if (rateLimit || (name === 'GitLab' && status === 429)) {
-      return error('RATE_LIMIT', `${name} API rate limit exceeded`, { status });
-    }
-    const detail = message ? `: ${oneLine(message)}` : ` HTTP ${status}`;
-    return error('HTTP', `${name} API${detail}`, { status });
-  };
-
-  const policy = (options) => ({
-    retry: options.retry ?? {},
-    isRetryable: (err) =>
-      err.code === `${prefix}_NETWORK` || TRANSIENT_STATUS.includes(err.status),
-    missingFetch: () => error('FETCH', 'fetch is not available'),
-    toHttpError: (status, body) => httpError(status, body, options.token),
-    wrapNetwork: (cause) => {
-      const detail = oneLine(cause && cause.message);
-      const suffix = detail ? `: ${detail}` : '';
-      return error('NETWORK', `${name} request failed${suffix}`, { cause });
-    },
-    method: options.method || 'GET',
-    headers: headers(options.token || '', options.accept),
-  });
-
-  const request = (url, options) => {
-    const init = policy(options);
-    if (options.contentType) init.headers['Content-Type'] = options.contentType;
-    return createTransport(options).request(url, {
-      ...init,
-      body: options.body,
-    });
-  };
-
-  const list = (url, options) =>
-    createTransport(options).listPages(url, {
-      ...policy(options),
-      method: 'GET',
-      parsePage: (text) => parseJson(text, 'list payload', Array.isArray),
-      nextPage,
-    });
-
-  return { parseJson, request, list, subject };
-};
+const commentBody = (value) => `${value ?? ''}`.trim();
 
 const sideLineNumber = (type, oldNo, newNo, side) => {
-  if (side === 'LEFT') {
-    if (type === 'add') return 0;
-    return oldNo;
-  }
-  if (type === 'del') return 0;
-  return newNo;
+  if (side === 'LEFT') return type === 'add' ? 0 : oldNo;
+  return type === 'del' ? 0 : newNo;
 };
 
 const locateLineInItem = (item, rel, line, side) => {
-  const path = itemPath(item);
-  if (path !== rel) return null;
   const hunk = item.hunk;
-  if (!hunk || !line) return null;
+  if (itemPath(item) !== rel || !hunk || !line) return null;
   let oldNo = hunk.oldStart;
   let newNo = hunk.newStart;
   for (const entry of hunk.lines) {
     const at = sideLineNumber(entry.type, oldNo, newNo, side);
-    if (at === line) {
-      const inBlock = entry.blockId === item.blockId;
-      return { inBlock };
-    }
-    if (isCtxType(entry.type) || entry.type === 'del') {
-      oldNo += 1;
-    }
-    if (isCtxType(entry.type) || entry.type === 'add') {
-      newNo += 1;
-    }
+    if (at === line) return { inBlock: entry.blockId === item.blockId };
+    const isCtx = isCtxType(entry.type);
+    if (isCtx || entry.type === 'del') oldNo += 1;
+    if (isCtx || entry.type === 'add') newNo += 1;
   }
   return null;
 };
@@ -270,8 +218,7 @@ const findItemForLine = (items, rel, line, side) => {
 
 const importedText = (entry, host) => {
   const reviewer = entry.reviewer || 'unknown';
-  const body = `${entry.body ?? ''}`.trim();
-  return `@${reviewer} review at ${host}: ${body}`;
+  return `@${reviewer} review at ${host}: ${commentBody(entry.body)}`;
 };
 
 const importedTodo = (file, entry, host) => ({
@@ -298,44 +245,46 @@ const importedFeedback = (item, path, entry, host) => {
 
 const noteFromLocation = (items, loc, entry, host, fallbackFile) => {
   const path = loc.path || '';
-  const line = loc.line;
-  const side = loc.side;
-  if (line && path) {
-    const item = findItemForLine(items, path, line, side);
+  if (loc.line && path) {
+    const item = findItemForLine(items, path, loc.line, loc.side);
     if (item) return importedFeedback(item, path, entry, host);
   }
-  if (path) return importedTodo(path, entry, host);
-  return importedTodo(fallbackFile, entry, host);
+  return importedTodo(path || fallbackFile, entry, host);
 };
 
-const changePath = (file) => file.newPath || file.oldPath || '';
+const splitNotes = (notes) => {
+  const feedback = [];
+  const tasks = [];
+  for (const note of notes) {
+    if (!note) continue;
+    if (note.kind === 'feedback') feedback.push(note);
+    else tasks.push(note);
+  }
+  return { feedback, tasks };
+};
 
 const filterChangeFiles = (files, paths) => {
   if (!paths.length) return files;
-  return files.filter((file) => isPathInScope(changePath(file), paths));
+  return files.filter((file) =>
+    isPathInScope(file.newPath || file.oldPath || '', paths),
+  );
 };
 
 const changeFiles = (items) => {
-  const files = new Set();
+  const rels = new Set();
   for (const item of items) {
     const paths = item.dep ? item.dep.files : [itemPath(item)];
     for (const rel of paths ?? []) {
-      if (rel) files.add(rel);
+      if (rel) rels.add(rel);
     }
   }
-  return [...files];
+  return [...rels];
 };
 
 const loadChange = async (ref, options, source) => {
   const { client, url, diffUrl = url, diffAccept } = source;
-  const {
-    cwd,
-    paths = [],
-    fetch = globalThis.fetch,
-    token = '',
-    retry = {},
-    signal,
-  } = options;
+  const { cwd, paths = [], fetch = globalThis.fetch } = options;
+  const { token = '', retry = {}, signal } = options;
   const request = { fetch, token, retry, signal };
   const jsonPage = await client.request(url, request);
   const data = client.parseJson(jsonPage.body, `${client.subject} payload`);
@@ -345,37 +294,32 @@ const loadChange = async (ref, options, source) => {
   });
   const files = filterChangeFiles(parseDiff(diffPage.body), paths);
   const items = foldDepItems(itemsFromFiles(files, 'pr'));
-  const change = source.toChange(ref, data, items);
+  const change = {
+    ...source.toChange(ref, data),
+    files: changeFiles(items),
+    status: 'reviewing',
+  };
   const sourceLabel = `${source.prefix}${change.number}`;
-  let imported = { feedback: [], todos: [] };
+  let imported = { feedback: [], tasks: [] };
   try {
     const discussion = await source.loadDiscussion(ref, request);
     imported = source.discussionToNotes(discussion, items, paths);
   } catch (error) {
-    if (isAbortError(error, request.signal)) throw error;
-    // Discussion import is optional.
+    if (isAbortError(error, signal)) throw error;
   }
   return { top: cwd, items, sourceLabel, change, imported };
 };
 
 module.exports = {
-  RETRY_ATTEMPTS,
-  RETRY_DELAY_MS,
-  TRANSIENT_STATUS,
-  isRecord,
+  RemoteClient,
   isAbortError,
-  createTransport,
-  headerValue,
   parseLinkNext,
   parseNextPage,
-  createClient,
   listUrl,
-  findItemForLine,
-  importedText,
+  commentBody,
   importedTodo,
   noteFromLocation,
-  changePath,
+  splitNotes,
   filterChangeFiles,
-  changeFiles,
   loadChange,
 };

package/lib/render/branches.js

@@ -3,14 +3,13 @@
 const ansi = require('../ansi.js');
 const files = require('../files.js');
 const primitives = require('./primitives.js');
+
 const { shortAge } = files;
+const { THEME, paint, visibleWidth, trimVisible, seq, EL } = ansi;
+const { MARK_W, markPrefix, branchLabel, editSpan } = primitives;
+const { paintCursorList, fieldWindow } = primitives;
 const { measureColumns, padColumns, joinColumns, paintColumns } = primitives;
 
-const { THEME, paint, visibleWidth, truncateVisible, seq, EL } = ansi;
-const { FILE_MARK } = primitives;
-const { paintCursorList, paintListEdit } = primitives;
-const { branchLabel } = primitives;
-
 const BRANCH_COL_ALIGN = {
   sha: 'end',
   ahead: 'start',
@@ -28,88 +27,91 @@ const BRANCH_COL_FG = {
 };
 
 const BRANCH_CURRENT_COL_FG = {
+  ...BRANCH_COL_FG,
   sha: THEME.shaDarkFg,
   date: THEME.headerFg,
 };
 
 const BRANCH_NAME_MAX = 24;
 const BRANCH_TAIL = 1;
+
 const branchNameChip = (entry, rowBg) => {
   if (entry.current) {
-    return {
-      nameFg: THEME.mutedFg,
-      nameBg: THEME.currentBg,
-      nameBold: false,
-    };
+    return { nameFg: THEME.mutedFg, nameBg: THEME.currentBg, nameBold: false };
   }
   if (entry.isDefault) {
-    return {
-      nameFg: THEME.warnFg,
-      nameBg: rowBg,
-      nameBold: true,
-    };
+    return { nameFg: THEME.warnFg, nameBg: rowBg, nameBold: true };
   }
-  return {
-    nameFg: THEME.buttonHotFg,
-    nameBg: rowBg,
-    nameBold: false,
-  };
+  return { nameFg: THEME.buttonHotFg, nameBg: rowBg, nameBold: false };
 };
 
-const branchRowFg = (entry, selected) => {
-  if (selected) return THEME.chromeFg;
-  return THEME.mutedFg;
-};
+const branchRowFields = (entry) => ({
+  sha: entry.sha ?? '',
+  ahead: entry.ahead ? `⇡${entry.ahead}` : '',
+  behind: entry.behind ? `⇣${entry.behind}` : '',
+  gone: entry.gone ? 'gone' : '',
+  date: shortAge(entry.date),
+});
 
-const branchRowFields = (entry) => {
-  const sha = entry.sha ?? '';
-  const date = shortAge(entry.date ?? '');
-  const gone = entry.gone ? 'gone' : '';
-  const ahead = entry.ahead ? `⇡${entry.ahead}` : '';
-  const behind = entry.behind ? `⇣${entry.behind}` : '';
-  return { sha, ahead, behind, gone, date };
+const branchRowFg = (entry, selected) => {
+  if (entry.current) return THEME.headerFg;
+  return selected ? THEME.chromeFg : THEME.mutedFg;
 };
 
 const branchRowBg = (entry, selected) => {
   if (entry.current) return THEME.currentBg;
-  if (selected) return THEME.buttonBg;
-  return THEME.ctxBg;
+  return selected ? THEME.buttonBg : THEME.ctxBg;
 };
 
 const paintBranchRow = (entry, width, color, selected, cols) => {
   const inner = Math.max(1, width - BRANCH_TAIL);
-  const mark = selected ? FILE_MARK : ' ';
-  const prefix = ` ${mark} `;
+  const prefix = markPrefix(selected);
   const parts = padColumns(branchRowFields(entry), cols, BRANCH_COL_ALIGN);
   const suffix = joinColumns(parts, cols);
   const rest = Math.max(1, inner - visibleWidth(prefix + suffix));
   const nameW = Math.min(cols.name, rest);
-  const label = truncateVisible(branchLabel(entry.name), nameW);
-  const namePad = Math.max(0, nameW - visibleWidth(label));
+  const label = trimVisible(branchLabel(entry.name), nameW);
+  const namePad = ' '.repeat(Math.max(0, nameW - visibleWidth(label)));
   const canSubject = rest >= nameW + 3;
   const gap = canSubject ? '  ' : '';
-  const subjectW = canSubject ? rest - nameW - visibleWidth(gap) : 0;
-  const subject = truncateVisible(entry.subject ?? '', subjectW);
-  const mid = `${label}${' '.repeat(namePad)}${gap}${subject}`;
-  const pad = Math.max(0, rest - visibleWidth(mid));
-  const after = `${' '.repeat(namePad)}${gap}${subject}${' '.repeat(pad)}`;
-  const left = `${prefix}${label}${after}`;
-  const fgRgb = branchRowFg(entry, selected);
-  const rowBg = branchRowBg(entry, selected);
-  const chip = branchNameChip(entry, rowBg);
-  const toneFg = entry.current ? THEME.headerFg : fgRgb;
+  const subjectW = canSubject ? rest - nameW - gap.length : 0;
+  const subject = trimVisible(entry.subject ?? '', subjectW);
+  const mid = `${label}${namePad}${gap}${subject}`;
+  const pad = ' '.repeat(Math.max(0, rest - visibleWidth(mid)));
+  const after = `${namePad}${gap}${subject}${pad}`;
   const tail = ' '.repeat(BRANCH_TAIL);
-  if (!color) return `${left}${suffix}${tail}`;
-  let out = `${seq(toneFg, rowBg)}${EL}`;
-  out += paint(prefix, toneFg, rowBg, color);
+  if (!color) return `${prefix}${label}${after}${suffix}${tail}`;
+  const fgRgb = branchRowFg(entry, selected);
+  const bgRgb = branchRowBg(entry, selected);
+  const chip = branchNameChip(entry, bgRgb);
+  const tones = entry.current ? BRANCH_CURRENT_COL_FG : BRANCH_COL_FG;
+  let out = `${seq(fgRgb, bgRgb)}${EL}`;
+  out += paint(prefix, fgRgb, bgRgb, color);
   out += paint(label, chip.nameFg, chip.nameBg, color, chip.nameBold);
-  out += paint(after, toneFg, rowBg, color);
-  const tones = entry.current
-    ? { ...BRANCH_COL_FG, ...BRANCH_CURRENT_COL_FG }
-    : BRANCH_COL_FG;
-  out += paintColumns(parts, cols, toneFg, rowBg, color, tones);
-  out += paint(tail, toneFg, rowBg, color);
-  return out;
+  out += paint(after, fgRgb, bgRgb, color);
+  out += paintColumns(parts, cols, fgRgb, bgRgb, color, tones);
+  return out + paint(tail, fgRgb, bgRgb, color);
+};
+
+const paintBranchEdit = (compose, width, color) => {
+  const prefix = markPrefix(true);
+  const rest = Math.max(1, width - MARK_W);
+  const text = `${compose.text ?? ''}`.replaceAll('\n', ' ');
+  const win = fieldWindow(text, compose.cursor, compose.scrollCol, rest);
+  const gap = ' '.repeat(Math.max(0, rest - visibleWidth(win.text)));
+  const fgRgb = THEME.chromeFg;
+  const bgRgb = THEME.buttonBg;
+  let row = `${prefix}${win.text}${gap}`;
+  if (color) {
+    row = `${seq(fgRgb, bgRgb)}${EL}`;
+    row += paint(prefix, fgRgb, bgRgb, color);
+    row += paint(win.text, THEME.buttonHotFg, bgRgb, color);
+    row += paint(gap, fgRgb, bgRgb, color);
+  }
+  const textX = MARK_W + 1;
+  const edit = editSpan(1, textX, textX + rest, 0, text);
+  const cursor = { x: textX + win.col, scroll: win.scroll };
+  return { row, cursor, edits: [{ ...edit, scroll: win.scroll }] };
 };
 
 const paintBodyBranches = (view, width, color, bodyH, headerLines) => {
@@ -121,22 +123,13 @@ const paintBodyBranches = (view, width, color, bodyH, headerLines) => {
   }
   cols.name = Math.min(BRANCH_NAME_MAX, cols.name);
   const cursor = view.branchCursor ?? 0;
-  const compose = view.compose;
-  const editing = compose && compose.kind === 'branch';
-  const tail = editing ? paintListEdit(compose, width, color) : null;
-  const paintRow = (entry, rowWidth, rowColor, selected) =>
-    paintBranchRow(entry, rowWidth, rowColor, selected, cols);
-  return paintCursorList(
-    branches,
-    cursor,
-    width,
-    color,
-    bodyH,
-    headerLines,
-    paintRow,
-    tail,
-    view.listScroll,
-  );
+  const { compose } = view;
+  const edit =
+    compose?.kind === 'branch' ? paintBranchEdit(compose, width, color) : null;
+  const pane = { width, color, bodyH, headerLines, offset: view.listScroll };
+  const paintRow = (entry, selected) =>
+    paintBranchRow(entry, width, color, selected, cols);
+  return paintCursorList(branches, cursor, pane, paintRow, edit);
 };
 
 module.exports = { paintBodyBranches };