reslop 0.2.3 → 0.2.5

package/lib/session/ops.js

@@ -1,8 +1,7 @@
 'use strict';
 
-const { stateView } = require('./accessors.js');
-
 const ASYNC_WITHOUT_UI = ['pull', 'push'];
+const QUIET_KIND = new Set(['staged', 'unstaged']);
 
 const pickRepoWrite = (repo, name, uiOpen) => {
   const asyncFn = repo[`${name}Async`];
@@ -20,28 +19,176 @@ const pickRepoWrite = (repo, name, uiOpen) => {
   };
 };
 
-const createOpsRunner = (ui) => {
-  const state = {
-    gitBusy: false,
-    busy: '',
-  };
+const showsBusy = (kind) => Boolean(kind) && !QUIET_KIND.has(kind);
 
-  const reset = () => {
-    state.gitBusy = false;
-    state.busy = '';
-  };
+class ChangeQueue {
+  constructor(ui, runner) {
+    this.ui = ui;
+    this.runner = runner;
+    this.jobs = [];
+    this.head = 0;
+    this.epoch = 0;
+    this.draining = false;
+    this.pumpQueued = false;
+    this.holding = false;
+    this.resume = null;
+    this.reloading = false;
+  }
 
-  const setBusy = (kind) => {
-    state.busy = kind;
-    ui.startProgress();
-  };
+  noteFree() {
+    const resume = this.resume;
+    this.resume = null;
+    if (resume) resume();
+  }
 
-  const clearBusy = () => {
-    state.busy = '';
-    ui.stopProgress();
-  };
+  dropJobs() {
+    this.jobs = [];
+    this.head = 0;
+  }
+
+  reset() {
+    this.epoch += 1;
+    this.dropJobs();
+    this.draining = false;
+    this.pumpQueued = false;
+    this.holding = false;
+    this.reloading = false;
+    this.noteFree();
+  }
+
+  armBusy(kind) {
+    if (!showsBusy(kind)) return;
+    this.ui.status = '';
+    this.ui.progressFrame = 0;
+    this.runner.setBusy(kind);
+  }
+
+  waitTurn() {
+    if (!this.runner.gitBusy || this.holding) return Promise.resolve();
+    return new Promise((resolve) => {
+      this.resume = resolve;
+    });
+  }
+
+  hasPendingBusy() {
+    const { jobs, head } = this;
+    for (let i = head; i < jobs.length; i++) {
+      if (showsBusy(jobs[i].kind)) return true;
+    }
+    return false;
+  }
+
+  releaseHold() {
+    this.holding = false;
+    this.runner.gitBusy = false;
+    this.noteFree();
+  }
+
+  startReload() {
+    const { ui } = this;
+    if (typeof ui.reloadAfterChange !== 'function') return void ui.paint();
+    this.reloading = true;
+    ui.reloadAfterChange(() => {
+      this.reloading = false;
+      ui.paint();
+    });
+  }
+
+  async takeJob(stamp) {
+    const job = this.jobs[this.head];
+    this.head += 1;
+    this.armBusy(job.kind);
+    try {
+      await job.write(this.ui.top);
+    } catch (error) {
+      if (stamp !== this.epoch) return 'stale';
+      this.ui.status = error.message;
+      return 'fail';
+    }
+    if (stamp !== this.epoch) return 'stale';
+    if (job.done) this.ui.status = job.done;
+    if (!this.hasPendingBusy()) this.runner.clearBusy();
+    return job.reload ? 'reload' : 'ok';
+  }
+
+  schedule() {
+    if (this.draining || this.pumpQueued) return;
+    this.pumpQueued = true;
+    queueMicrotask(() => {
+      this.pumpQueued = false;
+      void this.run();
+    });
+  }
 
-  const runRepo = (label, write) => {
+  finish(stamp, needReload) {
+    if (stamp !== this.epoch) return;
+    this.draining = false;
+    this.releaseHold();
+    if (this.head < this.jobs.length) return void this.schedule();
+    this.dropJobs();
+    if (needReload) this.startReload();
+    else this.ui.paint();
+  }
+
+  async run() {
+    const stamp = this.epoch;
+    this.draining = true;
+    if (this.runner.gitBusy && !this.holding) await this.waitTurn();
+    if (stamp !== this.epoch) return;
+    this.holding = true;
+    this.runner.gitBusy = true;
+    let needReload = false;
+    while (this.head < this.jobs.length) {
+      const result = await this.takeJob(stamp);
+      if (result === 'stale') return;
+      if (result === 'fail') {
+        needReload = true;
+        this.dropJobs();
+        break;
+      }
+      if (result === 'reload') needReload = true;
+    }
+    this.finish(stamp, needReload);
+  }
+
+  enqueue(job) {
+    if (this.reloading) {
+      this.ui.loader.bump();
+      this.reloading = false;
+      job.reload = true;
+    }
+    this.jobs.push(job);
+    this.armBusy(job.kind);
+    this.schedule();
+  }
+}
+
+class OpsRunner {
+  constructor(ui) {
+    this.ui = ui;
+    this.gitBusy = false;
+    this.busy = '';
+    this.queue = new ChangeQueue(ui, this);
+  }
+
+  setBusy(kind) {
+    this.busy = kind;
+    this.ui.startProgress();
+  }
+
+  clearBusy() {
+    this.busy = '';
+    this.ui.stopProgress();
+  }
+
+  reset() {
+    this.gitBusy = false;
+    this.busy = '';
+    this.queue.reset();
+  }
+
+  runRepo(label, write) {
+    const { ui } = this;
     try {
       write(ui.top);
       ui.status = label;
@@ -50,21 +197,23 @@ const createOpsRunner = (ui) => {
       ui.status = error.message;
       return false;
     }
-  };
+  }
 
-  const finishBusy = (done, after) => {
+  finishBusy(done, after) {
+    const { ui } = this;
     if (ui.done || ui.mode === 'confirmPush') return void ui.paint();
     if (!ui.status && after) after();
-    if (!ui.status && !state.busy) ui.status = done;
+    if (!ui.status && !this.busy) ui.status = done;
     ui.paint();
-  };
+  }
 
-  const runBusy = async (kind, done, write, after) => {
-    if (state.gitBusy) return;
-    state.gitBusy = true;
+  async runBusy(kind, done, write, after) {
+    const { ui } = this;
+    if (this.gitBusy) return;
+    this.gitBusy = true;
     ui.status = '';
     ui.progressFrame = 0;
-    setBusy(kind);
+    this.setBusy(kind);
     ui.paint();
     try {
       await write(ui.top);
@@ -75,23 +224,29 @@ const createOpsRunner = (ui) => {
         ui.status = error.message;
       }
     } finally {
-      clearBusy();
-      state.gitBusy = false;
+      this.clearBusy();
+      this.gitBusy = false;
+      this.queue.noteFree();
     }
-    finishBusy(done, after);
-  };
+    this.finishBusy(done, after);
+  }
 
-  return stateView(
-    state,
-    {
-      reset,
-      setBusy,
-      clearBusy,
-      runRepo,
-      runBusy,
-    },
-    ['gitBusy', 'busy'],
-  );
-};
+  runWrite(name, args, kind, done, after) {
+    const { ui } = this;
+    const picked = pickRepoWrite(ui.repo, name, ui.uiOpen);
+    const write = (top) => picked.write(top, ...args);
+    if (picked.async) {
+      const refresh = () => after({ doneStatus: done });
+      return void this.runBusy(kind, done, write, refresh);
+    }
+    if (!this.runRepo(done, write)) return;
+    after({});
+    if (!ui.status) ui.status = done;
+  }
+
+  enqueueLazy(job) {
+    this.queue.enqueue(job);
+  }
+}
 
-module.exports = { ASYNC_WITHOUT_UI, pickRepoWrite, createOpsRunner };
+module.exports = { pickRepoWrite, OpsRunner };

package/lib/session/pointer.js

@@ -1,8 +1,12 @@
 'use strict';
 
-const { extractText, isRange } = require('../select.js');
-const { hitAction } = require('../keys.js');
-const { copyText } = require('../clipboard.js');
+const select = require('../select.js');
+const editClick = require('./edit-click.js');
+const { extractText, isRange } = select;
+const keys = require('../keys.js');
+const { hitAction } = keys;
+const clipboard = require('../clipboard.js');
+const { copyText } = clipboard;
 
 const mouseCell = (ui, event) => {
   const size = ui.lastSize ?? ui.getSize();
@@ -45,6 +49,20 @@ const clickButton = (ui, cell, clickId) => {
   return true;
 };
 
+const DOUBLE_CLICK_MS = 500;
+
+const armDoubleClick = (nav, pane, cursor) => {
+  const now = Date.now();
+  const prev = nav.lastClick;
+  const again =
+    prev !== null &&
+    prev.pane === pane &&
+    prev.cursor === cursor &&
+    now - prev.at <= DOUBLE_CLICK_MS;
+  nav.lastClick = { pane, cursor, at: now };
+  return again;
+};
+
 const clickHit = (ui, hits, cell, onHit) => {
   const nav = ui.nav;
   if (!hits || isRange(nav.selection)) return false;
@@ -83,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();
     },
   },
   {
@@ -100,22 +120,26 @@ 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();
     },
   },
   {
     match: (ui) => ui.pane === 'npm',
     hits: 'fileHits',
     onHit: (ui, hit) => {
+      const again = armDoubleClick(ui.nav, 'npm', hit.cursor);
       ui.nav.npmCursor = hit.cursor;
+      if (again && ui.mode === 'review') ui.npm.run();
     },
   },
   {
     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);
     },
   },
   {
@@ -135,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,74 +1,56 @@
 'use strict';
 
-const { stateView } = require('./accessors.js');
-
 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 };