reslop 0.1.8 → 0.2.0

package/lib/session/ops.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { stateView } = require('./accessors.js');
+
 const ASYNC_WITHOUT_UI = ['pull', 'push'];
 
 const pickRepoWrite = (repo, name, uiOpen) => {
@@ -18,7 +20,7 @@ const pickRepoWrite = (repo, name, uiOpen) => {
   };
 };
 
-const createOpsRunner = (options) => {
+const createOpsRunner = (ui) => {
   const state = {
     gitBusy: false,
     busy: '',
@@ -31,53 +33,46 @@ const createOpsRunner = (options) => {
 
   const setBusy = (kind) => {
     state.busy = kind;
-    options.startProgress();
+    ui.startProgress();
   };
 
   const clearBusy = () => {
     state.busy = '';
-    options.stopProgress();
+    ui.stopProgress();
   };
 
   const runRepo = (label, write) => {
     try {
-      write(options.top());
-      options.setStatus(label);
+      write(ui.top);
+      ui.status = label;
       return true;
     } catch (error) {
-      options.setStatus(error.message);
+      ui.status = error.message;
       return false;
     }
   };
 
   const finishBusy = (done, after) => {
-    if (options.isDone()) {
-      options.paint();
-      return;
-    }
-    if (options.getMode() === 'confirmPush') {
-      options.paint();
-      return;
-    }
-    if (!options.getStatus() && after) after();
-    if (!options.getStatus() && !state.busy) options.setStatus(done);
-    options.paint();
+    if (ui.done || ui.mode === 'confirmPush') return void ui.paint();
+    if (!ui.status && after) after();
+    if (!ui.status && !state.busy) ui.status = done;
+    ui.paint();
   };
 
   const runBusy = async (kind, done, write, after) => {
     if (state.gitBusy) return;
     state.gitBusy = true;
-    options.setStatus('');
-    options.resetProgressFrame();
+    ui.status = '';
+    ui.progressFrame = 0;
     setBusy(kind);
-    options.paint();
+    ui.paint();
     try {
-      await write(options.top());
+      await write(ui.top);
     } catch (error) {
       if (error.rejected && kind !== 'force pushing') {
-        options.setMode('confirmPush');
+        ui.mode = 'confirmPush';
       } else {
-        options.setStatus(error.message);
+        ui.status = error.message;
       }
     } finally {
       clearBusy();
@@ -86,25 +81,17 @@ const createOpsRunner = (options) => {
     finishBusy(done, after);
   };
 
-  return {
-    get gitBusy() {
-      return state.gitBusy;
+  return stateView(
+    state,
+    {
+      reset,
+      setBusy,
+      clearBusy,
+      runRepo,
+      runBusy,
     },
-    set gitBusy(value) {
-      state.gitBusy = value;
-    },
-    get busy() {
-      return state.busy;
-    },
-    set busy(value) {
-      state.busy = value;
-    },
-    reset,
-    setBusy,
-    clearBusy,
-    runRepo,
-    runBusy,
-  };
+    ['gitBusy', 'busy'],
+  );
 };
 
 module.exports = { ASYNC_WITHOUT_UI, pickRepoWrite, createOpsRunner };

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,101 +55,104 @@ 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() === 'diff',
+    match: (ui) => ui.pane === 'commits',
+    hits: 'fileHits',
+    onHit: (ui, hit) => {
+      ui.nav.commitCursor = hit.cursor;
+    },
+  },
+  {
+    match: (ui) => ui.pane === 'diff',
     hits: 'todoHits',
-    onHit: (options, hit) => options.onTodoHit(hit.cursor),
+    onHit: (ui, hit) => 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

@@ -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;
 };
 
@@ -126,10 +128,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);
 };
 
@@ -234,10 +233,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;