reslop 0.2.5 → 0.2.7

package/lib/session/tasks.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const files = require('../files.js');
-const { isTasksEntry, TASKS_FILE } = files;
+const { isTasksEntry, TASKS_FILE, TASK_KINDS, taskKind } = files;
 const review = require('../review.js');
 const { addTask, setTaskText, setTaskDone, removeTask, checkLabel } = review;
 
@@ -24,269 +24,310 @@ const TASK_TYPE_SKIP = [
   'n',
   'p',
   'q',
+  'f',
+  'd',
+  't',
+  'b',
+  'r',
+  'c',
 ];
 
 const isTaskTypeKey = (key) => {
-  if (!key) return false;
+  if (!key || key.length !== 1 || key === ' ') return false;
   if (TASK_TYPE_SKIP.includes(key)) return false;
-  if (key.startsWith('ctrl-')) return false;
-  if (key.startsWith('alt-')) return false;
+  if (key.startsWith('ctrl-') || 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 clamp = (value, last) => Math.max(0, Math.min(value, last));
 
-const isDraftCompose = (api) => {
-  const { state } = api;
-  return state.composeKind === 'tasks' && state.composeTaskId === null;
-};
+class TaskPage {
+  constructor(composer) {
+    this.composer = composer;
+  }
 
-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;
-};
+  get ui() {
+    return this.composer.ui;
+  }
 
-const taskRowCount = (api) => {
-  if (!api.nav.tasksOpen) return 0;
-  return listTasks(api).length + 1;
-};
+  get nav() {
+    return this.composer.ui.nav;
+  }
 
-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;
-};
+  isOpen() {
+    return this.nav.pane === 'tasks';
+  }
 
-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;
-};
+  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;
+  }
 
-const openTasksPage = (api) => {
-  const nav = api.nav;
-  nav.tasksOpen = true;
-  nav.pane = 'diff';
-  nav.scroll = 0;
-  nav.clearSelection();
-  api.ui.syncReviewPath();
-};
+  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;
+  }
 
-const closeTasksPage = (api) => {
-  api.nav.tasksOpen = false;
-  api.ui.syncReviewPath();
-  api.ui.syncFileCursor();
-  api.ui.lifecycle.catchUpWatch();
-};
+  rowAt(index) {
+    return this.rows()[index] ?? null;
+  }
 
-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;
-};
+  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);
+  }
 
-const startDraftCompose = (api) => {
-  focusTodoPage(api, null);
-  api.open('tasks', '', null);
-};
+  editingId() {
+    const composer = this.composer;
+    return composer.composeKind === 'tasks' ? composer.composeTaskId : 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);
-};
+  isDraftCompose() {
+    const composer = this.composer;
+    return composer.composeKind === 'tasks' && composer.composeTaskId === null;
+  }
 
-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);
-};
+  canToggle() {
+    if (!this.isOpen()) return false;
+    return this.ui.mode === 'review';
+  }
 
-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);
-};
+  focused() {
+    const row = this.rowAt(this.clampedTaskFocus());
+    return row && row.task ? row.task : null;
+  }
 
-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;
-};
+  focusedKind() {
+    const row = this.rowAt(this.clampedTaskFocus());
+    return row ? row.kind : TASK_KINDS[0].id;
+  }
 
-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);
-};
+  closeEditor() {
+    this.composer.commitCompose();
+    this.composer.closeCompose();
+  }
 
-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;
-};
+  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;
+  }
 
-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);
-};
+  taskTexts() {
+    const texts = [];
+    for (const section of this.taskSections()) texts.push(...section.texts);
+    return texts;
+  }
 
-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);
-};
+  taskRowCount() {
+    if (!this.isOpen()) return 0;
+    return this.rows().length;
+  }
 
-const createTask = (api) => {
-  startDraftCompose(api);
-};
+  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);
+  }
 
-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;
+  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(TASK_KINDS[0].id).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);
   }
-  createTask(api);
-};
 
-const taskEditView = (api) => {
-  const { state } = api;
-  if (state.composeKind !== 'tasks') return null;
-  if (!state.editor) return null;
-  return { cursor: state.editor.cursor };
-};
+  editNextTask() {
+    if (!this.isOpen()) return;
+    const next = this.clampedTaskFocus() + 1;
+    if (next < this.taskRowCount()) this.nav.tasksFocus = next;
+    this.editFocusedTask();
+  }
 
-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;
-};
+  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();
+  }
 
-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,
-};
+  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 };