reslop 0.2.4 → 0.2.6

package/lib/session/tasks.js

@@ -0,0 +1,333 @@
+'use strict';
+
+const files = require('../files.js');
+const { isTasksEntry, TASKS_FILE, TASK_KINDS, taskKind } = 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',
+  'f',
+  'd',
+  't',
+  'b',
+  'r',
+  'c',
+];
+
+const isTaskTypeKey = (key) => {
+  if (!key) return false;
+  if (TASK_TYPE_SKIP.includes(key)) return false;
+  if (key.startsWith('ctrl-') || key.startsWith('alt-')) return false;
+  return key.charCodeAt(0) >= 32;
+};
+
+const clamp = (value, last) => Math.max(0, Math.min(value, last));
+
+class TaskPage {
+  constructor(composer) {
+    this.composer = composer;
+  }
+
+  get ui() {
+    return this.composer.ui;
+  }
+
+  get nav() {
+    return this.composer.ui.nav;
+  }
+
+  isOpen() {
+    return this.nav.pane === 'tasks';
+  }
+
+  list(kind) {
+    const notes = this.ui.review.store;
+    if (!notes) return [];
+    const rows = [];
+    for (const task of notes.tasks) {
+      if (taskKind(task) === kind) rows.push(task);
+    }
+    return rows;
+  }
+
+  rows() {
+    const rows = [];
+    for (const kind of TASK_KINDS) {
+      const tasks = this.list(kind.id);
+      for (const task of tasks) {
+        rows.push({ kind: kind.id, task, draft: false });
+      }
+      rows.push({ kind: kind.id, task: null, draft: true });
+    }
+    return rows;
+  }
+
+  rowAt(index) {
+    return this.rows()[index] ?? null;
+  }
+
+  rowIndex(dest) {
+    const rows = this.rows();
+    if (!dest) return 0;
+    for (let i = 0; i < rows.length; i++) {
+      const row = rows[i];
+      if (dest.draft) {
+        if (row.draft && row.kind === dest.kind) return i;
+        continue;
+      }
+      if (row.task && dest.task && row.task.id === dest.task.id) return i;
+    }
+    return clamp(0, rows.length - 1);
+  }
+
+  editingId() {
+    const composer = this.composer;
+    return composer.composeKind === 'tasks' ? composer.composeTaskId : null;
+  }
+
+  isDraftCompose() {
+    const composer = this.composer;
+    return composer.composeKind === 'tasks' && composer.composeTaskId === null;
+  }
+
+  canToggle() {
+    if (!this.isOpen()) return false;
+    return this.ui.mode === 'review';
+  }
+
+  focused() {
+    const row = this.rowAt(this.clampedTaskFocus());
+    return row && row.task ? row.task : null;
+  }
+
+  focusedKind() {
+    const row = this.rowAt(this.clampedTaskFocus());
+    return row ? row.kind : 'backlog';
+  }
+
+  closeEditor() {
+    this.composer.commitCompose();
+    this.composer.closeCompose();
+  }
+
+  taskSections() {
+    if (!this.isOpen()) return [];
+    const editor = this.composer.editor;
+    const editingId = this.editingId();
+    const draft = this.isDraftCompose();
+    const focus = this.clampedTaskFocus();
+    let at = 0;
+    const sections = [];
+    for (const kind of TASK_KINDS) {
+      const tasks = this.list(kind.id);
+      const texts = [];
+      for (const task of tasks) {
+        const live = editingId === task.id && editor;
+        texts.push(checkLabel(live ? editor.text : task.text, task.done));
+        at += 1;
+      }
+      const drafting = draft && at === focus && editor;
+      texts.push(checkLabel(drafting ? editor.text : '', false));
+      at += 1;
+      sections.push({ title: kind.title, texts });
+    }
+    return sections;
+  }
+
+  taskTexts() {
+    const texts = [];
+    for (const section of this.taskSections()) texts.push(...section.texts);
+    return texts;
+  }
+
+  taskRowCount() {
+    if (!this.isOpen()) return 0;
+    return this.rows().length;
+  }
+
+  clampedTaskFocus() {
+    return clamp(this.nav.tasksFocus, this.taskRowCount() - 1);
+  }
+
+  moveTaskFocus(delta) {
+    const count = this.taskRowCount();
+    if (!count) return;
+    this.nav.tasksFocus = clamp(this.clampedTaskFocus() + delta, count - 1);
+  }
+
+  openTasksPage() {
+    const nav = this.nav;
+    nav.tasksOpen = true;
+    nav.pane = 'tasks';
+    nav.scroll = 0;
+    nav.clearSelection();
+    this.ui.syncReviewPath();
+  }
+
+  closeTasksPage() {
+    this.nav.tasksOpen = false;
+    this.ui.syncReviewPath();
+    this.ui.syncFileCursor();
+    this.ui.lifecycle.catchUpWatch();
+  }
+
+  startDraftCompose() {
+    this.openTasksPage();
+    this.nav.tasksFocus = this.list('backlog').length;
+    this.nav.scroll = 0;
+    this.composer.openCompose('tasks', '', null);
+  }
+
+  editFocusedTask() {
+    if (!this.isOpen()) return;
+    const row = this.rowAt(this.clampedTaskFocus());
+    if (!row || row.draft) {
+      this.composer.openCompose('tasks', '', null);
+      return;
+    }
+    this.composer.openCompose('tasks', row.task.text, row.task.id);
+  }
+
+  editNextTask() {
+    if (!this.isOpen()) return;
+    const next = this.clampedTaskFocus() + 1;
+    if (next < this.taskRowCount()) this.nav.tasksFocus = next;
+    this.editFocusedTask();
+  }
+
+  moveTaskCompose(delta, width, extend) {
+    if (!this.isOpen()) return;
+    const editor = this.composer.editor;
+    if (editor && width) {
+      const before = editor.cursor;
+      editor.moveLine(delta, width, extend);
+      if (editor.cursor !== before || extend) return;
+    }
+    const rows = this.rows();
+    const at = this.clampedTaskFocus();
+    const next = clamp(at + delta, rows.length - 1);
+    if (next === at) return;
+    const dest = rows[next];
+    this.composer.commitCompose();
+    this.ui.flushReview();
+    this.composer.closeCompose();
+    this.nav.tasksFocus = this.rowIndex(dest);
+    this.editFocusedTask();
+  }
+
+  typeIntoTask(key) {
+    if (!this.canToggle() || !isTaskTypeKey(key)) return false;
+    this.editFocusedTask();
+    this.composer.editor.insert(key);
+    return true;
+  }
+
+  removeFocusedTask() {
+    const nav = this.nav;
+    if (!this.isOpen()) return;
+    const row = this.rowAt(this.clampedTaskFocus());
+    if (!row || !row.task) return;
+    const kind = row.kind;
+    removeTask(this.ui.review.store, row.task.id);
+    const rows = this.rows();
+    let focus = Math.min(nav.tasksFocus, rows.length - 1);
+    const at = rows[focus];
+    const prev = rows[focus - 1];
+    if (at && at.draft && prev && prev.task && prev.kind === kind) {
+      focus -= 1;
+    }
+    nav.tasksFocus = Math.max(0, focus);
+    this.ui.flushReview(true);
+  }
+
+  toggleFocusedTask() {
+    if (!this.canToggle()) return false;
+    const task = this.focused();
+    if (!task) return false;
+    setTaskDone(this.ui.review.store, task.id, !task.done);
+    this.ui.flushReview(true);
+    return true;
+  }
+
+  onTaskHit(cursor) {
+    if (!this.isOpen()) return;
+    const row = this.rowAt(cursor);
+    if (!row) return;
+    const composer = this.composer;
+    if (composer.composeKind === 'tasks') {
+      const same =
+        cursor === this.clampedTaskFocus() &&
+        ((row.draft && composer.composeTaskId === null) ||
+          (row.task && row.task.id === composer.composeTaskId));
+      if (same) return;
+      this.closeEditor();
+    }
+    this.nav.tasksFocus = cursor;
+    this.editFocusedTask();
+  }
+
+  onTaskCheck(cursor) {
+    if (!this.isOpen()) return;
+    const row = this.rowAt(cursor);
+    if (!row || !row.task) return void this.onTaskHit(cursor);
+    const composer = this.composer;
+    if (
+      composer.composeKind === 'tasks' &&
+      composer.composeTaskId !== row.task.id
+    ) {
+      this.closeEditor();
+    }
+    setTaskDone(this.ui.review.store, row.task.id, !row.task.done);
+    this.nav.tasksFocus = cursor;
+    this.ui.flushReview(true);
+  }
+
+  onTasks() {
+    const { nav } = this;
+    if (nav.pane === 'files') {
+      const entry = this.ui.fileCursorEntry();
+      if (entry && !isTasksEntry(entry)) {
+        nav.index = entry.openIndex ?? entry.firstIndex;
+      }
+    }
+    this.startDraftCompose();
+  }
+
+  taskEditView() {
+    const { composeKind, editor } = this.composer;
+    if (composeKind !== 'tasks' || !editor) return null;
+    return { cursor: editor.cursor };
+  }
+
+  commitTask(text) {
+    const notes = this.ui.review.store;
+    const id = this.composer.composeTaskId;
+    const prev =
+      id === null ? null : notes.tasks.find((task) => task.id === id);
+    if (prev) return void setTaskText(notes, id, text);
+    if (!text.trim()) return;
+    const kind = this.focusedKind();
+    const todo = addTask(notes, TASKS_FILE, text, false, kind);
+    this.composer.composeTaskId = todo.id;
+  }
+}
+
+module.exports = { TaskPage };

package/lib/session/templates.js

@@ -3,62 +3,54 @@
 const review = require('../review.js');
 const { rankedTemplates, prefixTemplates, TEMPLATE_SHOW } = review;
 
-const shownTemplates = (api) => {
-  const notes = api.review.store;
-  if (!notes) return [];
-  const { state } = api;
-  if (state.composeKind && state.composeKind !== 'feedback') return [];
-  const ranked = rankedTemplates(notes.templates);
-  const editing = state.composeKind && state.editor;
-  const typed = editing ? state.editor.text : '';
-  const exact = ranked.some((entry) => entry.text === typed);
-  if (exact) return [];
-  const matched = prefixTemplates(ranked, typed);
-  return matched.slice(0, TEMPLATE_SHOW);
-};
-
-const clampedTemplateIndex = (api, shown) => {
-  if (!shown.length) return -1;
-  if (api.state.templateIndex >= shown.length) return shown.length - 1;
-  return api.state.templateIndex;
-};
-
-const clearTemplatePick = (api) => {
-  api.state.templateIndex = -1;
-  api.state.templateFocus = false;
-};
-
-const focusTemplate = (api, index, apply) => {
-  const shown = shownTemplates(api);
-  if (!shown.length) return;
-  let i = index;
-  if (i < 0) i = shown.length - 1;
-  if (i >= shown.length) i = 0;
-  api.state.templateIndex = i;
-  api.state.templateFocus = true;
-  if (apply) api.state.editor.replace(shown[i].text);
-};
-
-const selectTemplate = (api, index) => {
-  const shown = shownTemplates(api);
-  if (!shown.length) return null;
-  focusTemplate(api, index, true);
-  return api.save();
-};
-
-const applyTemplate = (api) => {
-  if (api.state.composeKind !== 'feedback') return null;
-  const index = api.state.templateFocus ? api.state.templateIndex : 0;
-  return selectTemplate(api, index);
-};
-
-const createTemplatePick = (api) => ({
-  shownTemplates: () => shownTemplates(api),
-  clampedTemplateIndex: (shown) => clampedTemplateIndex(api, shown),
-  clearTemplatePick: () => clearTemplatePick(api),
-  focusTemplate: (index, apply) => focusTemplate(api, index, apply),
-  applyTemplate: () => applyTemplate(api),
-  selectTemplate: (index) => selectTemplate(api, index),
-});
-
-module.exports = { createTemplatePick };
+class TemplatePick {
+  constructor(composer) {
+    this.composer = composer;
+  }
+
+  shownTemplates() {
+    const notes = this.composer.ui.review.store;
+    if (!notes) return [];
+    const { composeKind, editor } = this.composer;
+    if (composeKind && composeKind !== 'feedback') return [];
+    const ranked = rankedTemplates(notes.templates);
+    const typed = composeKind && editor ? editor.text : '';
+    if (ranked.some((entry) => entry.text === typed)) return [];
+    return prefixTemplates(ranked, typed).slice(0, TEMPLATE_SHOW);
+  }
+
+  clampedTemplateIndex(shown) {
+    if (!shown.length) return -1;
+    return Math.min(this.composer.templateIndex, shown.length - 1);
+  }
+
+  clearTemplatePick() {
+    this.composer.templateIndex = -1;
+    this.composer.templateFocus = false;
+  }
+
+  focusTemplate(index, apply) {
+    const shown = this.shownTemplates();
+    if (!shown.length) return;
+    let i = index;
+    if (i < 0) i = shown.length - 1;
+    if (i >= shown.length) i = 0;
+    this.composer.templateIndex = i;
+    this.composer.templateFocus = true;
+    if (apply) this.composer.editor.replace(shown[i].text);
+  }
+
+  selectTemplate(index) {
+    if (!this.shownTemplates().length) return null;
+    this.focusTemplate(index, true);
+    return this.composer.saveCompose();
+  }
+
+  applyTemplate() {
+    const { composeKind, templateFocus, templateIndex } = this.composer;
+    if (composeKind !== 'feedback') return null;
+    return this.selectTemplate(templateFocus ? templateIndex : 0);
+  }
+}
+
+module.exports = { TemplatePick };

package/lib/session/terminal.js

@@ -10,156 +10,105 @@ const LEAVE_TERM =
   '\x1b[?1006l\x1b[?1002l\x1b[?7h\x1b[0 q\x1b[?12l\x1b[?25h\x1b[?1049l';
 
 const sameCursor = (a, b) => {
-  if (!a && !b) return true;
-  if (!a || !b) return false;
+  if (!a || !b) return !a && !b;
   return a.x === b.x && a.y === b.y;
 };
 
-const hasTimer = (api, name) => api.timers.has(name);
-
-const stopTimer = (api, name) => {
-  const id = api.timers.get(name);
-  if (id === undefined) return;
-  clearInterval(id);
-  api.timers.delete(name);
-};
+const sameSize = (a, b) =>
+  a !== null && a.width === b.width && a.height === b.height;
+
+class Terminal {
+  constructor({ stdin = null, stdout, proc = process }) {
+    this.stdin = stdin;
+    this.stdout = stdout;
+    this.proc = proc;
+    this.timers = new Map();
+    this.disposers = [];
+    this.open = false;
+    this.disposed = false;
+    this.resetCache();
+  }
 
-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();
-  api.timers.set(name, id);
-};
+  resetCache() {
+    this.carry = '';
+    this.lastFrame = null;
+    this.lastCursor = null;
+    this.lastSize = null;
+  }
 
-const restartTimer = (api, name, fn, ms) => {
-  stopTimer(api, name);
-  startTimer(api, name, fn, ms);
-};
+  hasTimer(name) {
+    return this.timers.has(name);
+  }
 
-const clearTimers = (api) => {
-  for (const name of [...api.timers.keys()]) stopTimer(api, name);
-};
+  cancel(name) {
+    const id = this.timers.get(name);
+    if (id === undefined) return;
+    clearTimeout(id);
+    this.timers.delete(name);
+  }
 
-const stopListening = (api) => {
-  while (api.disposers.length) {
-    const stop = api.disposers.pop();
-    stop();
+  later(name, fn, ms) {
+    if (this.disposed || this.timers.has(name)) return;
+    const id = setTimeout(() => {
+      this.timers.delete(name);
+      fn();
+    }, ms);
+    id.unref();
+    this.timers.set(name, id);
   }
-};
 
-const enter = (api) => {
-  if (api.state.disposed) return;
-  const { stdin, stdout, state } = api;
-  if (stdin && stdin.setRawMode) stdin.setRawMode(true);
-  if (stdin && typeof stdin.resume === 'function') stdin.resume();
-  stdout.write(ENTER_TERM);
-  state.open = true;
-};
+  clearTimers() {
+    for (const id of this.timers.values()) clearTimeout(id);
+    this.timers.clear();
+  }
 
-const leave = (api) => {
-  if (!api.state.open) return;
-  api.stdout.write(LEAVE_TERM);
-  if (api.stdin && api.stdin.setRawMode) api.stdin.setRawMode(false);
-  api.state.open = false;
-};
+  enter() {
+    if (this.disposed) return;
+    const stdin = this.stdin;
+    if (stdin && stdin.setRawMode) stdin.setRawMode(true);
+    if (stdin && stdin.resume) stdin.resume();
+    this.stdout.write(ENTER_TERM);
+    this.open = true;
+  }
 
-const resetCache = (api) => {
-  api.state.carry = '';
-  api.state.lastFrame = null;
-  api.state.lastPresentedCursor = null;
-  api.state.lastSize = null;
-};
+  leave() {
+    if (!this.open) return;
+    this.stdout.write(LEAVE_TERM);
+    if (this.stdin && this.stdin.setRawMode) this.stdin.setRawMode(false);
+    this.open = false;
+  }
 
-const close = (api) => {
-  stopListening(api);
-  clearTimers(api);
-  leave(api);
-  api.state.disposed = true;
-};
+  close() {
+    this.stopListening();
+    this.clearTimers();
+    this.leave();
+    this.disposed = true;
+  }
 
-const startListening = (api, handlers) => {
-  if (api.state.disposed) return;
-  const onData = (chunk) => handlers.onData(chunk);
-  const onResize = () => handlers.onResize();
-  api.disposers.push(listen(api.stdin, 'data', onData));
-  api.disposers.push(watchResize(api.stdout, api.proc, onResize));
-};
+  startListening({ onData, onResize }) {
+    if (this.disposed) return;
+    this.disposers.push(listen(this.stdin, 'data', onData));
+    this.disposers.push(watchResize(this.stdout, this.proc, onResize));
+  }
 
-const paint = (api, frame, size, cursor) => {
-  if (api.state.disposed) return;
-  const lastSize = api.state.lastSize;
-  const resized =
-    !lastSize ||
-    lastSize.width !== size.width ||
-    lastSize.height !== size.height;
-  if (
-    !resized &&
-    api.state.lastFrame &&
-    api.state.lastFrame.text === frame.text
-  ) {
-    if (sameCursor(api.state.lastPresentedCursor, cursor)) return;
-    api.state.lastPresentedCursor = cursor;
-    api.stdout.write(presentCursor(cursor));
-    return;
+  stopListening() {
+    while (this.disposers.length) this.disposers.pop()();
   }
-  api.state.lastSize = size;
-  api.state.lastFrame = frame;
-  api.state.lastPresentedCursor = cursor;
-  api.stdout.write(presentRows(frame.rows, { clear: resized, cursor }));
-};
 
-const createTerminal = (options) => {
-  const state = {
-    open: false,
-    disposed: false,
-    carry: '',
-    lastFrame: null,
-    lastPresentedCursor: null,
-    lastSize: null,
-  };
-  const api = {
-    stdin: options.stdin ?? null,
-    stdout: options.stdout,
-    proc: options.proc ?? process,
-    timers: new Map(),
-    disposers: [],
-    state,
-  };
-  return {
-    get lastFrame() {
-      return state.lastFrame;
-    },
-    get lastSize() {
-      return state.lastSize;
-    },
-    get carry() {
-      return state.carry;
-    },
-    set carry(value) {
-      state.carry = value;
-    },
-    get disposed() {
-      return state.disposed;
-    },
-    enter: () => enter(api),
-    leave: () => leave(api),
-    close: () => close(api),
-    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),
-    clearTimers: () => clearTimers(api),
-    hasTimer: (name) => hasTimer(api, name),
-    resetCache: () => resetCache(api),
-  };
-};
+  paint(frame, size, cursor) {
+    if (this.disposed) return;
+    const resized = !sameSize(this.lastSize, size);
+    const last = this.lastFrame;
+    this.lastFrame = frame;
+    if (!resized && last && last.text === frame.text) {
+      if (sameCursor(this.lastCursor, cursor)) return;
+      this.lastCursor = cursor;
+      return void this.stdout.write(presentCursor(cursor));
+    }
+    this.lastSize = size;
+    this.lastCursor = cursor;
+    this.stdout.write(presentRows(frame.rows, { clear: resized, cursor }));
+  }
+}
 
-module.exports = {
-  ENTER_TERM,
-  LEAVE_TERM,
-  sameCursor,
-  createTerminal,
-};
+module.exports = { ENTER_TERM, LEAVE_TERM, Terminal };