reslop 0.2.3 → 0.2.5

package/lib/session/tasks.js

@@ -0,0 +1,292 @@
+'use strict';
+
+const files = require('../files.js');
+const { isTasksEntry, TASKS_FILE } = files;
+const review = require('../review.js');
+const { addTask, setTaskText, setTaskDone, removeTask, checkLabel } = review;
+
+const TASK_TYPE_SKIP = [
+  'enter',
+  'escape',
+  'tab',
+  'backspace',
+  'delete',
+  'left',
+  'right',
+  'up',
+  'down',
+  'home',
+  'end',
+  'pageUp',
+  'pageDown',
+  'j',
+  'k',
+  'n',
+  'p',
+  'q',
+];
+
+const isTaskTypeKey = (key) => {
+  if (!key) return false;
+  if (TASK_TYPE_SKIP.includes(key)) return false;
+  if (key.startsWith('ctrl-')) return false;
+  if (key.startsWith('alt-')) return false;
+  return key.charCodeAt(0) >= 32;
+};
+
+const listTasks = (api) => {
+  const notes = api.review.store;
+  if (!notes) return [];
+  return notes.tasks;
+};
+
+const isDraftCompose = (api) => {
+  const { state } = api;
+  return state.composeKind === 'tasks' && state.composeTaskId === null;
+};
+
+const taskTexts = (api) => {
+  const nav = api.nav;
+  if (!nav.tasksOpen) return [];
+  const todos = listTasks(api);
+  const texts = new Array(todos.length + 1);
+  const { state } = api;
+  const editingTodo = state.composeKind === 'tasks';
+  const editingId = editingTodo ? state.composeTaskId : null;
+  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[i] = checkLabel(text, todo.done);
+  }
+  const draft = isDraftCompose(api) && state.editor ? state.editor.text : '';
+  texts[todos.length] = checkLabel(draft, false);
+  return texts;
+};
+
+const taskRowCount = (api) => {
+  if (!api.nav.tasksOpen) return 0;
+  return listTasks(api).length + 1;
+};
+
+const clampedTaskFocus = (api) => {
+  const last = Math.max(0, taskRowCount(api) - 1);
+  const focus = api.nav.tasksFocus;
+  if (focus < 0) return 0;
+  if (focus > last) return last;
+  return focus;
+};
+
+const moveTaskFocus = (api, delta) => {
+  const nav = api.nav;
+  if (!nav.tasksOpen) return;
+  const n = taskRowCount(api);
+  if (!n) return;
+  const next = clampedTaskFocus(api) + delta;
+  if (next < 0) nav.tasksFocus = 0;
+  else if (next >= n) nav.tasksFocus = n - 1;
+  else nav.tasksFocus = next;
+};
+
+const openTasksPage = (api) => {
+  const nav = api.nav;
+  nav.tasksOpen = true;
+  nav.pane = 'diff';
+  nav.scroll = 0;
+  nav.clearSelection();
+  api.ui.syncReviewPath();
+};
+
+const closeTasksPage = (api) => {
+  api.nav.tasksOpen = false;
+  api.ui.syncReviewPath();
+  api.ui.syncFileCursor();
+  api.ui.lifecycle.catchUpWatch();
+};
+
+const focusTodoPage = (api, todoId) => {
+  openTasksPage(api);
+  const todos = listTasks(api);
+  let focus = 0;
+  if (todoId === null) {
+    focus = todos.length;
+  } else if (todoId !== undefined) {
+    const at = todos.findIndex((todo) => todo.id === todoId);
+    if (at >= 0) focus = at;
+    else if (todos.length) focus = todos.length - 1;
+  }
+  api.nav.tasksFocus = focus;
+  api.nav.scroll = 0;
+  return true;
+};
+
+const startDraftCompose = (api) => {
+  focusTodoPage(api, null);
+  api.open('tasks', '', null);
+};
+
+const editFocusedTask = (api) => {
+  if (!api.nav.tasksOpen) return;
+  const todos = listTasks(api);
+  const todo = todos[clampedTaskFocus(api)];
+  if (!todo) return void startDraftCompose(api);
+  api.open('tasks', todo.text, todo.id);
+};
+
+const editNextTask = (api) => {
+  if (!api.nav.tasksOpen) return;
+  const last = taskRowCount(api) - 1;
+  const next = clampedTaskFocus(api) + 1;
+  if (next <= last) api.nav.tasksFocus = next;
+  editFocusedTask(api);
+};
+
+const moveTaskCompose = (api, delta, width, extend) => {
+  if (!api.nav.tasksOpen) return;
+  const editor = api.state.editor;
+  if (editor && width) {
+    const before = editor.cursor;
+    editor.moveLine(delta, width, extend);
+    if (editor.cursor !== before) return;
+    if (extend) return;
+  }
+  const last = taskRowCount(api) - 1;
+  const at = clampedTaskFocus(api);
+  let next = at + delta;
+  if (next < 0) next = 0;
+  if (next > last) next = last;
+  if (next === at) return;
+  api.commit();
+  api.ui.flushReview();
+  api.close();
+  const max = Math.max(0, taskRowCount(api) - 1);
+  api.nav.tasksFocus = Math.min(next, max);
+  editFocusedTask(api);
+};
+
+const typeIntoTask = (api, key) => {
+  const nav = api.nav;
+  if (!nav.tasksOpen) return false;
+  if (nav.pane !== 'diff') return false;
+  if (api.ui.mode !== 'review') return false;
+  if (!isTaskTypeKey(key)) return false;
+  editFocusedTask(api);
+  api.state.editor.insert(key);
+  return true;
+};
+
+const removeFocusedTask = (api) => {
+  const nav = api.nav;
+  if (nav.pane !== 'diff' || !nav.tasksOpen) return;
+  const todos = listTasks(api);
+  const todo = todos[clampedTaskFocus(api)];
+  if (!todo) return;
+  const notes = api.review.store;
+  removeTask(notes, todo.id);
+  const left = listTasks(api);
+  if (nav.tasksFocus >= left.length) {
+    nav.tasksFocus = Math.max(0, left.length - 1);
+  }
+  api.ui.flushReview(true);
+};
+
+const toggleFocusedTask = (api) => {
+  const nav = api.nav;
+  if (!nav.tasksOpen || nav.pane !== 'diff') return false;
+  if (api.ui.mode !== 'review') return false;
+  const todo = listTasks(api)[clampedTaskFocus(api)];
+  if (!todo) return false;
+  setTaskDone(api.review.store, todo.id, !todo.done);
+  api.ui.flushReview(true);
+  return true;
+};
+
+const onTaskHit = (api, cursor) => {
+  if (!api.nav.tasksOpen) return;
+  const todos = listTasks(api);
+  const draft = cursor === todos.length;
+  const target = todos[cursor];
+  if (!draft && !target) return;
+  const { state } = api;
+  if (state.composeKind === 'tasks') {
+    if (draft && state.composeTaskId === null) return;
+    if (target && target.id === state.composeTaskId) return;
+    api.commit();
+    api.close();
+  }
+  api.nav.tasksFocus = cursor;
+  editFocusedTask(api);
+};
+
+const onTaskCheck = (api, cursor) => {
+  if (!api.nav.tasksOpen) return;
+  const todo = listTasks(api)[cursor];
+  if (!todo) return void onTaskHit(api, cursor);
+  const { state } = api;
+  if (state.composeKind === 'tasks' && state.composeTaskId !== todo.id) {
+    api.commit();
+    api.close();
+  }
+  setTaskDone(api.review.store, todo.id, !todo.done);
+  api.nav.tasksFocus = cursor;
+  api.ui.flushReview(true);
+};
+
+const createTask = (api) => {
+  startDraftCompose(api);
+};
+
+const onTasks = (api) => {
+  const { nav, ui } = api;
+  if (nav.pane === 'files') {
+    const entry = ui.fileCursorEntry();
+    if (entry && !isTasksEntry(entry)) {
+      nav.index = entry.openIndex ?? entry.firstIndex;
+    }
+  }
+  createTask(api);
+};
+
+const taskEditView = (api) => {
+  const { state } = api;
+  if (state.composeKind !== 'tasks') return null;
+  if (!state.editor) return null;
+  return { cursor: state.editor.cursor };
+};
+
+const commitTask = (api, text) => {
+  const notes = api.review.store;
+  const id = api.state.composeTaskId;
+  const todos = notes.tasks;
+  const prev = id === null ? null : todos.find((entry) => entry.id === id);
+  if (prev) return void setTaskText(notes, id, text);
+  if (!text.trim()) return;
+  const todo = addTask(notes, TASKS_FILE, text);
+  api.state.composeTaskId = todo.id;
+};
+
+const createTasksCompose = (api) => ({
+  taskTexts: () => taskTexts(api),
+  clampedTaskFocus: () => clampedTaskFocus(api),
+  taskRowCount: () => taskRowCount(api),
+  moveTaskFocus: (delta) => moveTaskFocus(api, delta),
+  openTasksPage: () => openTasksPage(api),
+  closeTasksPage: () => closeTasksPage(api),
+  startDraftCompose: () => startDraftCompose(api),
+  editFocusedTask: () => editFocusedTask(api),
+  editNextTask: () => editNextTask(api),
+  moveTaskCompose: (delta, width, extend) =>
+    moveTaskCompose(api, delta, width, extend),
+  typeIntoTask: (key) => typeIntoTask(api, key),
+  removeFocusedTask: () => removeFocusedTask(api),
+  onTaskHit: (cursor) => onTaskHit(api, cursor),
+  onTaskCheck: (cursor) => onTaskCheck(api, cursor),
+  toggleFocusedTask: () => toggleFocusedTask(api),
+  onTasks: () => onTasks(api),
+  taskEditView: () => taskEditView(api),
+  commitTask: (text) => commitTask(api, text),
+});
+
+module.exports = {
+  createTasksCompose,
+};

package/lib/session/terminal.js

@@ -1,7 +1,9 @@
 'use strict';
 
-const { presentRows, presentCursor } = require('../render/render.js');
-const { listen, watchResize } = require('../utilities.js');
+const render = require('../render/render.js');
+const { presentRows, presentCursor } = render;
+const utilities = require('../utilities.js');
+const { listen, watchResize } = utilities;
 
 const ENTER_TERM = '\x1b[?1049h\x1b[?25l\x1b[?7l\x1b[?1002h\x1b[?1006h';
 const LEAVE_TERM =
@@ -15,28 +17,25 @@ const sameCursor = (a, b) => {
 
 const hasTimer = (api, name) => api.timers.has(name);
 
-const stopTimer = (api, name) => {
+const cancel = (api, name) => {
   const id = api.timers.get(name);
   if (id === undefined) return;
-  clearInterval(id);
+  clearTimeout(id);
   api.timers.delete(name);
 };
 
-const startTimer = (api, name, fn, ms) => {
-  if (api.state.disposed) return;
-  if (api.timers.has(name)) return;
-  const id = setInterval(fn, ms);
-  if (id && typeof id.unref === 'function') id.unref();
+const later = (api, name, fn, ms) => {
+  if (api.state.disposed || api.timers.has(name)) return;
+  const id = setTimeout(() => {
+    api.timers.delete(name);
+    fn();
+  }, ms);
+  if (typeof id.unref === 'function') id.unref();
   api.timers.set(name, id);
 };
 
-const restartTimer = (api, name, fn, ms) => {
-  stopTimer(api, name);
-  startTimer(api, name, fn, ms);
-};
-
 const clearTimers = (api) => {
-  for (const name of [...api.timers.keys()]) stopTimer(api, name);
+  for (const name of [...api.timers.keys()]) cancel(api, name);
 };
 
 const stopListening = (api) => {
@@ -96,6 +95,7 @@ const paint = (api, frame, size, cursor) => {
     api.state.lastFrame &&
     api.state.lastFrame.text === frame.text
   ) {
+    api.state.lastFrame = frame;
     if (sameCursor(api.state.lastPresentedCursor, cursor)) return;
     api.state.lastPresentedCursor = cursor;
     api.stdout.write(presentCursor(cursor));
@@ -146,9 +146,8 @@ const createTerminal = (options) => {
     paint: (frame, size, cursor) => paint(api, frame, size, cursor),
     startListening: (handlers) => startListening(api, handlers),
     stopListening: () => stopListening(api),
-    startTimer: (name, fn, ms) => startTimer(api, name, fn, ms),
-    stopTimer: (name) => stopTimer(api, name),
-    restartTimer: (name, fn, ms) => restartTimer(api, name, fn, ms),
+    later: (name, fn, ms) => later(api, name, fn, ms),
+    cancel: (name) => cancel(api, name),
     clearTimers: () => clearTimers(api),
     hasTimer: (name) => hasTimer(api, name),
     resetCache: () => resetCache(api),
@@ -158,6 +157,5 @@ const createTerminal = (options) => {
 module.exports = {
   ENTER_TERM,
   LEAVE_TERM,
-  sameCursor,
   createTerminal,
 };

package/lib/session/unit.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const files = require('../files.js');
-const { listPath, isTodosEntry } = files;
+const { listPath, isTasksEntry } = files;
 const diff = require('../diff/diff.js');
 const { unitLines, itemsForPath, blockLineIndex } = diff;
 const { hunkLineRange, sameHunk, hunkKey } = diff;
@@ -150,10 +150,10 @@ const moveUnitBlock = (ui, step) => {
 };
 
 const openUnitFile = (ui, entry) => {
-  if (!entry || isTodosEntry(entry)) return;
+  if (!entry || isTasksEntry(entry)) return;
   const nav = ui.nav;
   nav.reviewPath = entry.path;
-  nav.todoOpen = false;
+  nav.tasksOpen = false;
   nav.pane = 'unit';
   nav.scroll = 0;
   nav.unitLine = 0;
@@ -203,6 +203,5 @@ module.exports = {
   openUnitFile,
   setFileScope,
   editCursor,
-  ensureVisible,
   followFileCursor,
 };

package/lib/session/update.js

@@ -1,112 +1,92 @@
 'use strict';
 
-const { stateView } = require('./accessors.js');
-
 const update = require('../update.js');
 const { checkUpdate, installUpdate, markSkipped } = update;
 
-const optsOf = (api) => {
-  const value = api.ui.updateOpts;
-  if (!value || value === true) return {};
-  return value;
-};
-
-const reset = (state) => {
-  state.offer = false;
-  state.from = '';
-  state.to = '';
-  state.checkPromise = null;
-  state.installPromise = null;
-};
+class UpdateCoordinator {
+  constructor(ui) {
+    this.ui = ui;
+    this.reset();
+  }
 
-const maybePrompt = (api) => {
-  if (!api.state.offer) return;
-  if (!api.ui.loader.didLoad) return;
-  if (api.ui.mode !== 'review') return;
-  api.ui.mode = 'confirmUpdate';
-};
+  get opts() {
+    const value = this.ui.updateOpts;
+    if (!value || value === true) return {};
+    return value;
+  }
 
-const runInstall = async (api, version) => {
-  api.ui.status = 'updating reslop';
-  api.ui.progressFrame = 0;
-  api.ui.progress.start('install');
-  api.ui.paint();
-  let ok = false;
-  try {
-    await installUpdate(version, optsOf(api));
-    ok = true;
-  } catch {
-    // ignore install errors
+  reset() {
+    this.offer = false;
+    this.from = '';
+    this.to = '';
+    this.checkPromise = null;
+    this.installPromise = null;
   }
-  api.ui.progress.stop('install');
-  if (api.ui.done || !api.ui.uiOpen) return;
-  api.ui.status = ok ? 'updated' : 'update failed';
-  api.ui.paint();
-};
 
-const acceptUpdate = (api) => {
-  api.ui.mode = 'review';
-  api.state.offer = false;
-  const version = api.state.to;
-  api.state.installPromise = runInstall(api, version);
-};
+  maybePrompt() {
+    const { ui } = this;
+    if (!this.offer || !ui.loader.didLoad) return;
+    if (ui.mode === 'review') ui.mode = 'confirmUpdate';
+  }
 
-const declineUpdate = (api) => {
-  api.ui.mode = 'review';
-  api.state.offer = false;
-  api.ui.status = '';
-  markSkipped(api.state.to, optsOf(api));
-};
+  async install(version) {
+    const { ui } = this;
+    ui.status = 'updating reslop';
+    ui.progressFrame = 0;
+    ui.progress.start('install');
+    ui.paint();
+    let ok = false;
+    try {
+      await installUpdate(version, this.opts);
+      ok = true;
+    } catch {
+      // ignore install errors
+    }
+    ui.progress.stop('install');
+    if (ui.done || !ui.uiOpen) return;
+    ui.status = ok ? 'updated' : 'update failed';
+    ui.paint();
+  }
 
-const runOpenUpdate = async (api) => {
-  let plan;
-  try {
-    plan = await checkUpdate(optsOf(api));
-  } catch {
-    return;
+  accept() {
+    this.ui.mode = 'review';
+    this.offer = false;
+    this.installPromise = this.install(this.to);
   }
-  if (api.ui.done) return;
-  if (plan.action === 'install') {
-    api.state.installPromise = runInstall(api, plan.latest);
-    await api.state.installPromise;
-    return;
+
+  decline() {
+    this.ui.mode = 'review';
+    this.offer = false;
+    this.ui.status = '';
+    markSkipped(this.to, this.opts);
   }
-  if (plan.action !== 'confirm') return;
-  api.state.from = plan.current;
-  api.state.to = plan.latest;
-  api.state.offer = true;
-  maybePrompt(api);
-  api.ui.paint();
-};
 
-const openUpdate = (api) => {
-  if (api.ui.updateOpts === false) return Promise.resolve();
-  if (api.state.checkPromise) return api.state.checkPromise;
-  api.state.checkPromise = runOpenUpdate(api);
-  return api.state.checkPromise;
-};
+  async check() {
+    let plan;
+    try {
+      plan = await checkUpdate(this.opts);
+    } catch {
+      return;
+    }
+    if (this.ui.done) return;
+    if (plan.action === 'install') {
+      this.installPromise = this.install(plan.latest);
+      await this.installPromise;
+      return;
+    }
+    if (plan.action !== 'confirm') return;
+    this.from = plan.current;
+    this.to = plan.latest;
+    this.offer = true;
+    this.maybePrompt();
+    this.ui.paint();
+  }
 
-const createUpdateCoordinator = (ui) => {
-  const state = {
-    offer: false,
-    from: '',
-    to: '',
-    checkPromise: null,
-    installPromise: null,
-  };
-  const api = { ui, state };
-  return stateView(
-    state,
-    {
-      reset: () => reset(state),
-      maybePrompt: () => maybePrompt(api),
-      accept: () => acceptUpdate(api),
-      decline: () => declineUpdate(api),
-      open: () => openUpdate(api),
-    },
-    ['offer', 'installPromise'],
-    ['from', 'to', 'checkPromise'],
-  );
-};
+  open() {
+    if (this.ui.updateOpts === false) return Promise.resolve();
+    if (!this.checkPromise) this.checkPromise = this.check();
+    return this.checkPromise;
+  }
+}
 
-module.exports = { createUpdateCoordinator };
+module.exports = { UpdateCoordinator };