reslop 0.2.4 → 0.2.5

package/lib/session/pointer.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const select = require('../select.js');
+const editClick = require('./edit-click.js');
 const { extractText, isRange } = select;
 const keys = require('../keys.js');
 const { hitAction } = keys;
@@ -100,16 +101,18 @@ const RELEASE_TARGETS = [
     match: (ui) => ui.pane === 'files',
     hits: 'fileHits',
     onHit: (ui, hit) => {
+      const again = armDoubleClick(ui.nav, 'files', hit.cursor);
       ui.nav.fileCursor = hit.cursor;
-      ui.filesPane.onOpenFile();
+      if (again) ui.filesPane.onOpenFile();
     },
   },
   {
     match: (ui) => ui.pane === 'branches',
     hits: 'fileHits',
     onHit: (ui, hit) => {
+      const again = armDoubleClick(ui.nav, 'branches', hit.cursor);
       ui.nav.branchCursor = hit.cursor;
-      ui.gitBranches.onCheckoutBranch();
+      if (again) ui.gitBranches.onCheckoutBranch();
     },
   },
   {
@@ -117,7 +120,9 @@ const RELEASE_TARGETS = [
     hits: 'fileHits',
     onHit: (ui, hit) => {
       if (ui.mode === 'compose') return;
+      const again = armDoubleClick(ui.nav, 'commits', hit.cursor);
       ui.nav.commitCursor = hit.cursor;
+      if (again) ui.filesPane.onOpenFile();
     },
   },
   {
@@ -131,10 +136,10 @@ const RELEASE_TARGETS = [
   },
   {
     match: (ui) => ui.pane === 'diff',
-    hits: 'todoHits',
+    hits: 'taskHits',
     onHit: (ui, hit) => {
-      if (hit.check) return void ui.composer.onTodoCheck(hit.cursor);
-      ui.composer.onTodoHit(hit.cursor);
+      if (hit.check) return void ui.composer.onTaskCheck(hit.cursor);
+      ui.composer.onTaskHit(hit.cursor);
     },
   },
   {
@@ -154,6 +159,7 @@ const onRelease = (ui, event) => {
   nav.pendingClick = null;
   nav.mouseAnchor = null;
   if (clickButton(ui, cell, clickId)) return;
+  if (editClick.placeClick(ui, cell)) return;
   const frame = ui.lastFrame;
   for (const target of RELEASE_TARGETS) {
     if (!target.match(ui)) continue;

package/lib/session/progress.js

@@ -3,22 +3,25 @@
 const createProgress = (term, onTick, intervalMs) => {
   const active = new Set();
 
+  const tick = () => {
+    if (!active.size) return;
+    onTick();
+    term.later('progress', tick, intervalMs);
+  };
+
   const start = (id) => {
-    const wasEmpty = active.size === 0;
     active.add(id);
-    if (wasEmpty) {
-      term.startTimer('progress', onTick, intervalMs);
-    }
+    term.later('progress', tick, intervalMs);
   };
 
   const stop = (id) => {
     active.delete(id);
-    if (active.size === 0) term.stopTimer('progress');
+    if (active.size === 0) term.cancel('progress');
   };
 
   const clear = () => {
     active.clear();
-    term.stopTimer('progress');
+    term.cancel('progress');
   };
 
   const size = () => active.size;

package/lib/session/review.js

@@ -1,75 +1,56 @@
 'use strict';
 
-const accessors = require('./accessors.js');
-const { stateView } = accessors;
-
 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,
-    importedRemote: false,
-  };
+class ReviewController {
+  constructor() {
+    this.store = null;
+    this.didResume = false;
+    this.importedRemote = false;
+  }
 
-  const reset = () => {
-    state.store = null;
-    state.didResume = false;
-    state.importedRemote = false;
-  };
+  reset() {
+    this.store = null;
+    this.didResume = false;
+    this.importedRemote = false;
+  }
 
-  const init = (dir, date, extra = {}) => {
+  init(dir, date, extra = {}) {
     const names = listReviewNames(dir);
     const templates = loadTemplates(dir);
     const resolved = resolveReviewPath(dir, date, names, extra);
-    if (resolved.resume) {
-      state.store = loadReview(resolved.reviewPath, templates);
-      state.didResume = true;
-      return state.store;
-    }
-    state.store = createStore(resolved.reviewPath, templates);
-    state.didResume = false;
-    return state.store;
-  };
-
-  const applyImported = (imported) => {
-    if (!imported || !state.store) return false;
-    if (state.didResume || state.importedRemote) return false;
-    applyImportedNotes(state.store, imported);
-    state.importedRemote = true;
+    this.didResume = resolved.resume === true;
+    this.store = this.didResume
+      ? loadReview(resolved.reviewPath, templates)
+      : createStore(resolved.reviewPath, templates);
+    return this.store;
+  }
+
+  applyImported(imported) {
+    if (!imported || !this.store) return false;
+    if (this.didResume || this.importedRemote) return false;
+    applyImportedNotes(this.store, imported);
+    this.importedRemote = true;
     return true;
-  };
+  }
 
-  const flush = (force = false) => {
-    if (!state.store) return { ok: true, wrote: false };
+  flush(force = false) {
+    if (!this.store) return { ok: true, wrote: false };
     try {
-      const wrote = flushReview(state.store, force);
+      const wrote = flushReview(this.store, force);
       return { ok: true, wrote };
     } catch (error) {
       return { ok: false, wrote: false, error };
     }
-  };
-
-  const finishQuit = (status) => {
-    setStatus(state.store, status);
-    return flush();
-  };
+  }
 
-  return stateView(
-    state,
-    {
-      reset,
-      init,
-      applyImported,
-      flush,
-      finishQuit,
-    },
-    [],
-    ['store', 'didResume', 'importedRemote'],
-  );
-};
+  finishQuit(status) {
+    setStatus(this.store, status);
+    return this.flush();
+  }
+}
 
-module.exports = { createReviewController };
+module.exports = { ReviewController };

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

@@ -17,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) => {
@@ -98,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));
@@ -148,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),
@@ -160,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,
 };