reslop 0.1.9 → 0.2.1

package/lib/session/pointer.js

@@ -2,50 +2,51 @@
 
 const { extractText, isRange } = require('../select.js');
 const { hitAction } = require('../keys.js');
+const { copyText } = require('../clipboard.js');
 
-const mouseCell = (options, event) => {
-  const size = options.getSize();
+const mouseCell = (ui, event) => {
+  const size = ui.lastSize ?? ui.getSize();
   const x = Math.min(Math.max(1, event.x), size.width);
   const y = Math.min(Math.max(1, event.y), size.height);
   return { x, y };
 };
 
-const onPress = (options, event) => {
-  const nav = options.nav;
-  const cell = mouseCell(options, event);
+const onPress = (ui, event) => {
+  const nav = ui.nav;
+  const cell = mouseCell(ui, event);
   nav.mouseAnchor = cell;
   nav.pendingClick = null;
   nav.selection = null;
-  const frame = options.lastFrame();
+  const frame = ui.lastFrame;
   if (frame && cell.y === frame.height) {
     nav.pendingClick = hitAction(frame.buttons, cell.x - 1);
   }
 };
 
-const onDrag = (options, event) => {
-  const nav = options.nav;
+const onDrag = (ui, event) => {
+  const nav = ui.nav;
   if (!nav.mouseAnchor) return;
   nav.pendingClick = null;
   nav.selection = {
     start: nav.mouseAnchor,
-    end: mouseCell(options, event),
+    end: mouseCell(ui, event),
   };
 };
 
-const clickButton = (options, cell, clickId) => {
-  const nav = options.nav;
-  const frame = options.lastFrame();
+const clickButton = (ui, cell, clickId) => {
+  const nav = ui.nav;
+  const frame = ui.lastFrame;
   if (!clickId || !frame || isRange(nav.selection)) return false;
   const id = hitAction(frame.buttons, cell.x - 1);
   if (id === clickId && cell.y === frame.height) {
-    options.dispatch(id);
+    ui.dispatch(id);
   }
   nav.selection = null;
   return true;
 };
 
-const clickHit = (options, hits, cell, onHit) => {
-  const nav = options.nav;
+const clickHit = (ui, hits, cell, onHit) => {
+  const nav = ui.nav;
   if (!hits || isRange(nav.selection)) return false;
   const x = cell.x - 1;
   const hit = hits.find((row) => {
@@ -54,108 +55,107 @@ const clickHit = (options, hits, cell, onHit) => {
     return x >= row.x0 && x < row.x1;
   });
   if (!hit) return false;
-  onHit(options, hit);
+  onHit(ui, hit);
   nav.selection = null;
   return true;
 };
 
-const copySelection = (options) => {
-  const nav = options.nav;
-  const frame = options.lastFrame();
+const copySelection = (ui) => {
+  const nav = ui.nav;
+  const frame = ui.lastFrame;
   if (!isRange(nav.selection) || !frame) return;
   const text = extractText(frame.rows, nav.selection);
   if (!text) return;
-  const ok = options.copyText(text, options.stdout());
-  options.setStatus(ok ? 'copied' : 'copy failed');
+  const ok = copyText(text, ui.stdout);
+  ui.status = ok ? 'copied' : 'copy failed';
 };
 
 const RELEASE_TARGETS = [
   {
     match: () => true,
     hits: 'statusHits',
-    onHit: (options, hit) => {
-      if (hit.id === 'branch') {
-        options.onBranch();
-        return;
-      }
-      options.confirmChoice(hit.id);
+    onHit: (ui, hit) => {
+      if (hit.id === 'branch') return void ui.gitBranches.onBranch();
+      ui.input.confirmChoice(hit.id);
     },
   },
   {
-    match: (options) => options.getPane() === 'files',
+    match: (ui) => ui.pane === 'files',
     hits: 'fileHits',
-    onHit: (options, hit) => {
-      options.nav.fileCursor = hit.cursor;
-      options.onOpenFile();
+    onHit: (ui, hit) => {
+      ui.nav.fileCursor = hit.cursor;
+      ui.filesPane.onOpenFile();
     },
   },
   {
-    match: (options) => options.getPane() === 'branches',
+    match: (ui) => ui.pane === 'branches',
     hits: 'fileHits',
-    onHit: (options, hit) => {
-      options.nav.branchCursor = hit.cursor;
-      options.onCheckoutBranch();
+    onHit: (ui, hit) => {
+      ui.nav.branchCursor = hit.cursor;
+      ui.gitBranches.onCheckoutBranch();
     },
   },
   {
-    match: (options) => options.getPane() === 'commits',
+    match: (ui) => ui.pane === 'commits',
     hits: 'fileHits',
-    onHit: (options, hit) => {
-      options.nav.commitCursor = hit.cursor;
+    onHit: (ui, hit) => {
+      ui.nav.commitCursor = hit.cursor;
     },
   },
   {
-    match: (options) => options.getPane() === 'diff',
+    match: (ui) => ui.pane === 'diff',
     hits: 'todoHits',
-    onHit: (options, hit) => options.onTodoHit(hit.cursor),
+    onHit: (ui, hit) => {
+      if (hit.check) return void ui.composer.onTodoCheck(hit.cursor);
+      ui.composer.onTodoHit(hit.cursor);
+    },
   },
   {
-    match: (options) => options.getMode() === 'compose',
+    match: (ui) => ui.mode === 'compose',
     hits: 'templateHits',
-    onHit: (options, hit) => options.selectTemplate(hit.cursor),
+    onHit: (ui, hit) => ui.selectTemplate(hit.cursor),
   },
 ];
 
-const onRelease = (options, event) => {
-  const nav = options.nav;
-  const cell = mouseCell(options, event);
+const onRelease = (ui, event) => {
+  const nav = ui.nav;
+  const cell = mouseCell(ui, event);
   if (nav.mouseAnchor) {
     nav.selection = { start: nav.mouseAnchor, end: cell };
   }
   const clickId = nav.pendingClick;
   nav.pendingClick = null;
   nav.mouseAnchor = null;
-  if (clickButton(options, cell, clickId)) return;
-  const frame = options.lastFrame();
+  if (clickButton(ui, cell, clickId)) return;
+  const frame = ui.lastFrame;
   for (const target of RELEASE_TARGETS) {
-    if (!target.match(options)) continue;
+    if (!target.match(ui)) continue;
     const hits = frame?.[target.hits];
-    const opened = clickHit(options, hits, cell, target.onHit);
+    const opened = clickHit(ui, hits, cell, target.onHit);
     if (opened) return;
   }
-  copySelection(options);
+  copySelection(ui);
 };
 
 const POINTER_HANDLERS = {
-  wheelUp: (options) => options.onScroll(-1),
-  wheelDown: (options) => options.onScroll(1),
+  wheelUp: (ui) => ui.filesPane.onScroll(-1),
+  wheelDown: (ui) => ui.filesPane.onScroll(1),
   press: onPress,
   drag: onDrag,
   release: onRelease,
 };
 
-const handle = (options, event) => {
+const handle = (ui, event) => {
   const kind = event.kind;
   const handler = POINTER_HANDLERS[kind];
   if (!handler) return;
   const isWheel = kind === 'wheelUp' || kind === 'wheelDown';
   if (!isWheel && event.btn !== 0 && event.btn !== undefined) return;
-  handler(options, event);
+  handler(ui, event);
 };
 
-const createPointer = (options) => ({
-  handle: (event) => handle(options, event),
-  mouseCell: (event) => mouseCell(options, event),
+const createPointer = (ui) => ({
+  handle: (event) => handle(ui, event),
 });
 
 module.exports = { createPointer };

package/lib/session/review.js

@@ -1,13 +1,13 @@
 'use strict';
 
-const store = require('../review/store.js');
-const { createStore, applyImportedNotes, setStatus } = store;
-const storage = require('../review/storage.js');
-const { listReviewNames, loadTemplates, resolveReviewPath } = storage;
-const { loadReview, flushReview } = storage;
+const { stateView } = require('./accessors.js');
 
-const createReviewController = (options) => {
-  const io = options.storage;
+const review = require('../review.js');
+const { createStore, applyImportedNotes, setStatus } = review;
+const { listReviewNames, loadTemplates, resolveReviewPath } = review;
+const { loadReview, flushReview } = review;
+
+const createReviewController = () => {
   const state = {
     store: null,
     didResume: false,
@@ -21,15 +21,11 @@ const createReviewController = (options) => {
   };
 
   const init = (dir, date, extra = {}) => {
-    const forceNew = extra.forceNew ?? false;
-    const names = listReviewNames(dir, io.readdirSync);
-    const templates = loadTemplates(dir, io.readFileSync);
-    const resolved = resolveReviewPath(dir, date, names, {
-      forceNew,
-      readFileSync: io.readFileSync,
-    });
+    const names = listReviewNames(dir);
+    const templates = loadTemplates(dir);
+    const resolved = resolveReviewPath(dir, date, names, extra);
     if (resolved.resume) {
-      state.store = loadReview(resolved.reviewPath, templates, io.readFileSync);
+      state.store = loadReview(resolved.reviewPath, templates);
       state.didResume = true;
       return state.store;
     }
@@ -49,13 +45,7 @@ const createReviewController = (options) => {
   const flush = (force = false) => {
     if (!state.store) return { ok: true, wrote: false };
     try {
-      const writeFileSync = io.writeFileSync;
-      const mkdirSync = io.mkdirSync;
-      const wrote = flushReview(state.store, {
-        writeFileSync,
-        mkdirSync,
-        force,
-      });
+      const wrote = flushReview(state.store, force);
       return { ok: true, wrote };
     } catch (error) {
       return { ok: false, wrote: false, error };
@@ -67,22 +57,18 @@ const createReviewController = (options) => {
     return flush();
   };
 
-  return {
-    get store() {
-      return state.store;
-    },
-    get didResume() {
-      return state.didResume;
+  return stateView(
+    state,
+    {
+      reset,
+      init,
+      applyImported,
+      flush,
+      finishQuit,
     },
-    get importedRemote() {
-      return state.importedRemote;
-    },
-    reset,
-    init,
-    applyImported,
-    flush,
-    finishQuit,
-  };
+    [],
+    ['store', 'didResume', 'importedRemote'],
+  );
 };
 
 module.exports = { createReviewController };

package/lib/session/terminal.js

@@ -1,7 +1,7 @@
 'use strict';
 
-const { presentRows, presentCursor } = require('../render.js');
-const { listen, watchResize } = require('../sys.js');
+const { presentRows, presentCursor } = require('../render/render.js');
+const { listen, watchResize } = require('../utilities.js');
 
 const ENTER_TERM = '\x1b[?1049h\x1b[?25l\x1b[?7l\x1b[?1002h\x1b[?1006h';
 const LEAVE_TERM =
@@ -18,14 +18,16 @@ const hasTimer = (api, name) => api.timers.has(name);
 const stopTimer = (api, name) => {
   const id = api.timers.get(name);
   if (id === undefined) return;
-  api.clearIntervalFn(id);
+  clearInterval(id);
   api.timers.delete(name);
 };
 
 const startTimer = (api, name, fn, ms) => {
   if (api.state.disposed) return;
   if (api.timers.has(name)) return;
-  api.timers.set(name, api.setIntervalFn(fn, ms));
+  const id = setInterval(fn, ms);
+  if (id && typeof id.unref === 'function') id.unref();
+  api.timers.set(name, id);
 };
 
 const restartTimer = (api, name, fn, ms) => {
@@ -118,8 +120,6 @@ const createTerminal = (options) => {
     stdin: options.stdin ?? null,
     stdout: options.stdout,
     proc: options.proc ?? process,
-    setIntervalFn: options.setInterval ?? setInterval,
-    clearIntervalFn: options.clearInterval ?? clearInterval,
     timers: new Map(),
     disposers: [],
     state,
@@ -131,18 +131,12 @@ const createTerminal = (options) => {
     get lastSize() {
       return state.lastSize;
     },
-    get lastPresentedCursor() {
-      return state.lastPresentedCursor;
-    },
     get carry() {
       return state.carry;
     },
     set carry(value) {
       state.carry = value;
     },
-    get isOpen() {
-      return state.open;
-    },
     get disposed() {
       return state.disposed;
     },

package/lib/session/todos.js

@@ -3,7 +3,7 @@
 const files = require('../files.js');
 const { isTodosEntry, TODO_FILE } = files;
 const review = require('../review.js');
-const { addTodo, setTodoText, removeTodo, checkLabel } = review;
+const { addTodo, setTodoText, setTodoDone, removeTodo, checkLabel } = review;
 
 const TODO_TYPE_SKIP = [
   'enter',
@@ -48,17 +48,19 @@ const isDraftCompose = (api) => {
 const todoTexts = (api) => {
   const nav = api.nav;
   if (!nav.todoOpen) return [];
-  const texts = [];
+  const todos = listTodos(api);
+  const texts = new Array(todos.length + 1);
   const { state } = api;
   const editingTodo = state.composeKind === 'todo';
   const editingId = editingTodo ? state.composeTodoId : null;
-  for (const todo of listTodos(api)) {
+  for (let i = 0; i < todos.length; i++) {
+    const todo = todos[i];
     const live = editingId === todo.id && state.editor;
     const text = live ? state.editor.text : todo.text;
-    texts.push(checkLabel(text, todo.done));
+    texts[i] = checkLabel(text, todo.done);
   }
   const draft = isDraftCompose(api) && state.editor ? state.editor.text : '';
-  texts.push(checkLabel(draft, false));
+  texts[todos.length] = checkLabel(draft, false);
   return texts;
 };
 
@@ -99,6 +101,7 @@ const closeTodoPage = (api) => {
   api.nav.todoOpen = false;
   api.ui.syncReviewPath();
   api.ui.syncFileCursor();
+  api.ui.lifecycle.catchUpWatch();
 };
 
 const focusTodoPage = (api, todoId) => {
@@ -126,10 +129,7 @@ const editFocusedTodo = (api) => {
   if (!api.nav.todoOpen) return;
   const todos = listTodos(api);
   const todo = todos[clampedTodoFocus(api)];
-  if (!todo) {
-    startDraftCompose(api);
-    return;
-  }
+  if (!todo) return void startDraftCompose(api);
   api.open('todo', todo.text, todo.id);
 };
 
@@ -190,6 +190,17 @@ const removeFocusedTodo = (api) => {
   api.ui.flushReview(true);
 };
 
+const toggleFocusedTodo = (api) => {
+  const nav = api.nav;
+  if (!nav.todoOpen || nav.pane !== 'diff') return false;
+  if (api.ui.mode !== 'review') return false;
+  const todo = listTodos(api)[clampedTodoFocus(api)];
+  if (!todo) return false;
+  setTodoDone(api.review.store, todo.id, !todo.done);
+  api.ui.flushReview(true);
+  return true;
+};
+
 const onTodoHit = (api, cursor) => {
   if (!api.nav.todoOpen) return;
   const todos = listTodos(api);
@@ -207,6 +218,20 @@ const onTodoHit = (api, cursor) => {
   editFocusedTodo(api);
 };
 
+const onTodoCheck = (api, cursor) => {
+  if (!api.nav.todoOpen) return;
+  const todo = listTodos(api)[cursor];
+  if (!todo) return void onTodoHit(api, cursor);
+  const { state } = api;
+  if (state.composeKind === 'todo' && state.composeTodoId !== todo.id) {
+    api.commit();
+    api.close();
+  }
+  setTodoDone(api.review.store, todo.id, !todo.done);
+  api.nav.todoFocus = cursor;
+  api.ui.flushReview(true);
+};
+
 const createTodo = (api) => {
   startDraftCompose(api);
 };
@@ -234,10 +259,7 @@ const commitTodo = (api, text) => {
   const id = api.state.composeTodoId;
   const todos = notes.todos;
   const prev = id === null ? null : todos.find((entry) => entry.id === id);
-  if (prev) {
-    setTodoText(notes, id, text);
-    return;
-  }
+  if (prev) return void setTodoText(notes, id, text);
   if (!text.trim()) return;
   const todo = addTodo(notes, TODO_FILE, text);
   api.state.composeTodoId = todo.id;
@@ -257,6 +279,8 @@ const createTodoCompose = (api) => ({
   typeIntoTodo: (key) => typeIntoTodo(api, key),
   removeFocusedTodo: () => removeFocusedTodo(api),
   onTodoHit: (cursor) => onTodoHit(api, cursor),
+  onTodoCheck: (cursor) => onTodoCheck(api, cursor),
+  toggleFocusedTodo: () => toggleFocusedTodo(api),
   onTodo: () => onTodo(api),
   todoEditView: () => todoEditView(api),
   commitTodo: (text) => commitTodo(api, text),

package/lib/session/unit.js

@@ -0,0 +1,208 @@
+'use strict';
+
+const files = require('../files.js');
+const { listPath, isTodosEntry } = files;
+const diff = require('../diff/diff.js');
+const { unitLines, itemsForPath, blockLineIndex } = diff;
+const { hunkLineRange, sameHunk, hunkKey } = diff;
+const { fileOffset, splitEditor, mergeEditRows, fileLineIndex } = diff;
+
+const fileText = (ui, rel) => {
+  if (!rel) return '';
+  const repo = ui.repo;
+  if (repo && typeof repo.fileText === 'function') {
+    return repo.fileText(ui.top, rel, ui.rev);
+  }
+  return '';
+};
+
+const pathItems = (ui, rel) => itemsForPath(ui.items ?? [], rel);
+
+const linesFor = (
+  ui,
+  rel,
+  overlay = ui.composer.liveFileText(),
+  base = null,
+) => {
+  const text = overlay === null ? fileText(ui, rel) : overlay;
+  const group = pathItems(ui, rel);
+  if (overlay !== null && base && base.length) {
+    return mergeEditRows(base, splitEditor(text));
+  }
+  return unitLines(text, group);
+};
+
+const BODY_SHIFT = 1;
+
+const clampUnitLine = (nav, length) => {
+  if (!length) {
+    nav.unitLine = 0;
+    return;
+  }
+  if (nav.unitLine < 0) nav.unitLine = 0;
+  if (nav.unitLine >= length) nav.unitLine = length - 1;
+};
+
+const CONTEXT = 1;
+
+const frameBodyH = (frame, ui) => {
+  if (frame && frame.bodyH) return frame.bodyH;
+  const size = ui?.lastSize ?? ui?.getSize?.();
+  const height = size && size.height ? size.height : 24;
+  return Math.max(1, height - 4);
+};
+
+const ensureRangeVisible = (nav, firstLine, lastLine, frame, ui) => {
+  const bodyH = frameBodyH(frame, ui);
+  const diffFirst = firstLine + BODY_SHIFT;
+  const diffLast = lastLine + BODY_SHIFT;
+  const diffSpan = diffLast - diffFirst + 1;
+  let first = diffFirst;
+  let last = diffLast;
+  if (diffSpan <= bodyH) {
+    const padFirst = Math.max(0, firstLine - CONTEXT) + BODY_SHIFT;
+    const padLast = lastLine + CONTEXT + BODY_SHIFT;
+    if (padLast - padFirst + 1 <= bodyH) {
+      first = padFirst;
+      last = padLast;
+    }
+  }
+  const span = last - first + 1;
+  let scroll = nav.scroll ?? 0;
+  if (span > bodyH) {
+    scroll = first;
+  } else {
+    if (first < scroll) scroll = first;
+    const viewLast = scroll + bodyH - 1;
+    if (last > viewLast) scroll = last - bodyH + 1;
+  }
+  nav.scroll = Math.max(0, scroll);
+};
+
+const ensureVisible = (nav, length, frame) => {
+  clampUnitLine(nav, length);
+  ensureRangeVisible(nav, nav.unitLine, nav.unitLine, frame);
+};
+
+const followFileCursor = (nav, editor, frame, rows) => {
+  if (!editor) return;
+  const fileLine = editor.linePos().line;
+  if (rows && rows.length) {
+    nav.unitLine = fileLineIndex(rows, fileLine);
+    ensureVisible(nav, rows.length, frame);
+    return;
+  }
+  const length = `${editor.text}`.split('\n').length;
+  nav.unitLine = fileLine;
+  ensureVisible(nav, length, frame);
+};
+
+const jumpToItem = (ui, item) => {
+  const nav = ui.nav;
+  const rel = nav.reviewPath;
+  const lines = linesFor(ui, rel);
+  const items = ui.items ?? [];
+  const idx = items.indexOf(item);
+  if (idx >= 0) nav.index = idx;
+  const range = hunkLineRange(lines, item);
+  nav.unitLine = range.start;
+  ensureRangeVisible(nav, range.start, range.end, ui.lastFrame, ui);
+};
+
+const viewLine = (nav, length) => {
+  if (!length) return 0;
+  const top = Math.max(0, (nav.scroll ?? 0) - 1);
+  return Math.min(top, length - 1);
+};
+
+const moveUnitBlock = (ui, step) => {
+  const nav = ui.nav;
+  const rel = nav.reviewPath;
+  if (!rel) return;
+  const items = ui.items ?? [];
+  const indexes = [];
+  const seen = new Set();
+  for (let i = 0; i < items.length; i++) {
+    if (listPath(items[i]) !== rel) continue;
+    const key = hunkKey(items[i]);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    indexes.push(i);
+  }
+  if (!indexes.length) {
+    ui.status = 'not a diff block';
+    return;
+  }
+  let at = -1;
+  const current = items[nav.index];
+  for (let i = 0; i < indexes.length; i++) {
+    if (!sameHunk(items[indexes[i]], current)) continue;
+    at = i;
+    break;
+  }
+  if (at < 0) at = step > 0 ? -1 : 0;
+  const next = at + step;
+  if (next < 0 || next >= indexes.length) return;
+  const item = items[indexes[next]];
+  jumpToItem(ui, item);
+  ui.status = '';
+  nav.clearSelection();
+};
+
+const openUnitFile = (ui, entry) => {
+  if (!entry || isTodosEntry(entry)) return;
+  const nav = ui.nav;
+  nav.reviewPath = entry.path;
+  nav.todoOpen = false;
+  nav.pane = 'unit';
+  nav.scroll = 0;
+  nav.unitLine = 0;
+  nav.clearSelection();
+  const items = ui.items ?? [];
+  const group = pathItems(ui, entry.path);
+  if (group.length) {
+    const want = items[entry.openIndex] ?? items[entry.firstIndex] ?? group[0];
+    const item = group.includes(want) ? want : group[0];
+    jumpToItem(ui, item);
+  } else {
+    nav.unitLine = 0;
+  }
+  ui.status = '';
+};
+
+const setFileScope = (ui, next) => {
+  if (ui.nav.pane !== 'files') return;
+  if (ui.nav.fileScope === next) return;
+  ui.nav.fileScope = next;
+  ui.nav.restoreFileCursor(ui.fileList());
+  ui.status = next === 'file' ? 'file scope' : 'diff mode';
+};
+
+const editCursor = (ui) => {
+  const rel = ui.nav.reviewPath;
+  const text = fileText(ui, rel);
+  const group = pathItems(ui, rel);
+  const lines = unitLines(text, group);
+  const items = ui.items ?? [];
+  const item = items[ui.nav.index];
+  const atBlock = item && listPath(item) === rel;
+  const at = atBlock
+    ? blockLineIndex(lines, item)
+    : viewLine(ui.nav, lines.length);
+  return {
+    text,
+    cursor: fileOffset(lines, at),
+    rows: lines,
+  };
+};
+
+module.exports = {
+  fileText,
+  linesFor,
+  moveUnitBlock,
+  openUnitFile,
+  setFileScope,
+  editCursor,
+  ensureVisible,
+  followFileCursor,
+};