reslop 0.1.9 → 0.2.0

package/lib/session/lifecycle.js

@@ -4,10 +4,10 @@ const fs = require('node:fs');
 const path = require('node:path');
 
 const { isAbortError } = require('./load.js');
-const { createDiskWatcher, POLL_MS } = require('./watch.js');
+const { createDiskWatcher, POLL_MS, DEBOUNCE_MS } = require('./watch.js');
 const files = require('../files.js');
 const { itemPath, relativeAge } = files;
-const { MANIFEST, LOCKFILE } = require('../deps/manifest.js');
+const { MANIFEST, LOCKFILE } = require('../deps.js');
 const review = require('../review.js');
 const { hasNotes } = review;
 
@@ -30,8 +30,6 @@ const shouldDeferExtras = (api) => {
   return audit && (waitingOutdated || waitingAudit);
 };
 
-const watchOpts = (api) => api.watch ?? {};
-
 const endReadLoop = (api) => {
   const finish = api.ui.finishReadLoop;
   if (finish) finish();
@@ -50,8 +48,6 @@ const kindFromExtra = (extra = {}) => {
   return 'reload';
 };
 
-const shouldResetNav = (kind) => kind !== 'open' && kind !== 'watch';
-
 const finishIfEmpty = (api, kind) => {
   const { collection, review: notes, ui, nav } = api;
   if (collection.items.length) return;
@@ -125,9 +121,25 @@ const stampItemDates = (items, dates) => {
   }
 };
 
+const syncUnitEditor = (api) => {
+  const composer = api.ui.composer;
+  if (!composer || typeof composer.applyDiskText !== 'function') return;
+  if (api.nav.pane !== 'unit') return;
+  const rel = api.nav.reviewPath;
+  if (!rel) return;
+  const repo = api.ui.repo;
+  if (!repo || typeof repo.fileText !== 'function') return;
+  const text = repo.fileText(api.ui.top || api.loadConfig.cwd, rel, api.ui.rev);
+  composer.applyDiskText(text);
+};
+
 const syncItemWatches = (api) => {
   if (!api.diskWatcher) return;
-  api.diskWatcher.watchFiles(itemRels(api.collection));
+  const rels = itemRels(api.collection);
+  if (api.nav.pane === 'unit' && api.nav.reviewPath) {
+    if (!rels.includes(api.nav.reviewPath)) rels.push(api.nav.reviewPath);
+  }
+  api.diskWatcher.watchFiles(rels);
 };
 
 const applyLoaded = (api, loaded) => {
@@ -160,6 +172,7 @@ const applyLoaded = (api, loaded) => {
   markLoaded(api);
   loader.pendingExtras = loaded.pending === true;
   syncItemWatches(api);
+  syncUnitEditor(api);
   return true;
 };
 
@@ -173,10 +186,10 @@ const load = (api) => {
   applyLoaded(api, loaded);
 };
 
-const fileStamp = (top, rel, statSync) => {
+const fileStamp = (top, rel) => {
   const full = path.join(top, rel);
   try {
-    const stat = statSync(full);
+    const stat = fs.statSync(full);
     return `${stat.mtimeMs}:${stat.size}`;
   } catch {
     return 'missing';
@@ -184,11 +197,9 @@ const fileStamp = (top, rel, statSync) => {
 };
 
 const npmStamp = (api) => {
-  const extra = watchOpts(api);
-  const statSync = extra.statSync ?? fs.statSync;
   const top = api.ui.top || api.loadConfig.cwd;
-  const pkg = fileStamp(top, MANIFEST, statSync);
-  const lock = fileStamp(top, LOCKFILE, statSync);
+  const pkg = fileStamp(top, MANIFEST);
+  const lock = fileStamp(top, LOCKFILE);
   return `${pkg}|${lock}`;
 };
 
@@ -216,8 +227,7 @@ const followExtras = async (api, loaded, gen, kind) => {
     next = await api.loader.fetchExtras(api.loadConfig.repo, loaded, extra);
   } catch (error) {
     if (!api.loader.isCurrent(gen)) return;
-    failOpen(api, error);
-    return;
+    return void failOpen(api, error);
   }
   if (!api.loader.isCurrent(gen)) return;
   if (api.ui.done) {
@@ -267,9 +277,8 @@ const resetNavAfterLoad = (api, extra = {}) => {
 };
 
 const afterSnapshot = (api, kind, extra = {}) => {
-  if (shouldResetNav(kind)) {
-    resetNavAfterLoad(api, extra);
-    return;
+  if (kind !== 'open' && kind !== 'watch') {
+    return void resetNavAfterLoad(api, extra);
   }
   if (extra.afterLoad) extra.afterLoad();
 };
@@ -296,8 +305,7 @@ const runSnapshot = async (api, gen, kind, extra = {}) => {
     );
   } catch (error) {
     if (!api.loader.isCurrent(gen)) return;
-    failOpen(api, error);
-    return;
+    return void failOpen(api, error);
   }
   if (!api.loader.isCurrent(gen)) return;
   if (api.ui.done) {
@@ -354,8 +362,7 @@ const refreshFromRepo = (api, extra = {}) => {
   afterSnapshot(api, kind, extra);
   if (loaded.pending) {
     api.ops.setBusy('checking npm');
-    followExtras(api, loaded, gen, kind);
-    return;
+    return void followExtras(api, loaded, gen, kind);
   }
   if (kind === 'keep') return;
   finishIfEmpty(api, kind);
@@ -377,8 +384,7 @@ const reloadAfterChange = (api, afterLoad) => {
     if (afterLoad) afterLoad();
   };
   if (api.ui.uiOpen && api.loadConfig.repo.loadAsync) {
-    refreshFromRepo(api, { afterLoad: restore });
-    return;
+    return void refreshFromRepo(api, { afterLoad: restore });
   }
   refreshFromRepo(api);
   restore();
@@ -392,9 +398,7 @@ const onReload = (api) => {
 
 const clearWatchRetry = (api) => {
   if (api.watchRetry === null) return;
-  const extra = watchOpts(api);
-  const clearTimeoutFn = extra.clearTimeout ?? clearTimeout;
-  clearTimeoutFn(api.watchRetry);
+  clearTimeout(api.watchRetry);
   api.watchRetry = null;
 };
 
@@ -404,6 +408,10 @@ const shouldDeferWatch = (api) => {
   if (!ui.uiOpen) return true;
   if (!api.loader.didLoad) return true;
   if (ops.gitBusy) return true;
+  if (ui.mode === 'compose') {
+    const kind = ui.composer && ui.composer.state.composeKind;
+    if (kind === 'file') return false;
+  }
   if (ui.mode !== 'review') return true;
   return false;
 };
@@ -411,38 +419,32 @@ const shouldDeferWatch = (api) => {
 const WATCH_IGNORE_MS = 500;
 
 const ignoreWatch = (api, ms = WATCH_IGNORE_MS) => {
-  const extra = watchOpts(api);
-  const now = extra.now ?? Date.now;
-  api.ignoreWatchUntil = now() + ms;
+  api.ignoreWatchUntil = Date.now() + ms;
 };
 
 const onDiskChange = (api) => {
-  const extra = watchOpts(api);
-  const now = extra.now ?? Date.now;
-  if (now() < (api.ignoreWatchUntil ?? 0)) return;
+  if (Date.now() < (api.ignoreWatchUntil ?? 0)) return;
   if (shouldDeferWatch(api)) {
     if (api.watchRetry !== null) return;
-    const setTimeoutFn = extra.setTimeout ?? setTimeout;
-    const delay = extra.debounceMs ?? 200;
-    api.watchRetry = setTimeoutFn(() => {
+    api.watchRetry = setTimeout(() => {
       api.watchRetry = null;
       onDiskChange(api);
-    }, delay);
+    }, DEBOUNCE_MS);
+    if (typeof api.watchRetry.unref === 'function') api.watchRetry.unref();
     return;
   }
   refreshFromRepo(api, { keepView: true, quiet: true });
 };
 
 const currentFileStamp = (api) => {
-  if (api.nav.pane !== 'diff') return '';
-  const rel = itemPath(api.ui.current());
+  const pane = api.nav.pane;
+  if (pane !== 'diff' && pane !== 'unit') return '';
+  const rel = pane === 'unit' ? api.nav.reviewPath : itemPath(api.ui.current());
   if (!rel) return '';
-  const extra = watchOpts(api);
-  const statSync = extra.statSync ?? fs.statSync;
   const full = path.join(api.ui.top || api.loadConfig.cwd, rel);
   let stat;
   try {
-    stat = statSync(full);
+    stat = fs.statSync(full);
   } catch {
     return `${rel}:missing`;
   }
@@ -478,12 +480,10 @@ const startWatch = (api) => {
   if (!isWorktree(api.ui)) return;
   const root = api.ui.top || api.loadConfig.cwd;
   if (!root) return;
-  const extra = watchOpts(api);
   api.diskWatcher = createDiskWatcher({
     root,
     paths: api.loadConfig.paths,
     onChange: () => onDiskChange(api),
-    ...extra,
   });
   syncItemWatches(api);
   if (!api.ui.term) return;

package/lib/session/load.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { stateView } = require('./accessors.js');
+
 const isAbortError = (error) => !!(error && error.code === 'ABORT');
 
 const createLoadCoordinator = () => {
@@ -46,40 +48,24 @@ const createLoadCoordinator = () => {
     return repo.loadExtras(loaded, extra);
   };
 
-  return {
-    get gen() {
-      return state.gen;
-    },
-    get promise() {
-      return state.promise;
-    },
-    set promise(value) {
-      state.promise = value;
-    },
-    get pendingExtras() {
-      return state.pendingExtras;
-    },
-    set pendingExtras(value) {
-      state.pendingExtras = value;
+  return stateView(
+    state,
+    {
+      get signal() {
+        return state.abort?.signal;
+      },
+      bump,
+      isCurrent,
+      accept,
+      abort,
+      reset,
+      tag,
+      fetchSnapshot,
+      fetchExtras,
     },
-    get didLoad() {
-      return state.didLoad;
-    },
-    set didLoad(value) {
-      state.didLoad = value;
-    },
-    get signal() {
-      return state.abort?.signal;
-    },
-    bump,
-    isCurrent,
-    accept,
-    abort,
-    reset,
-    tag,
-    fetchSnapshot,
-    fetchExtras,
-  };
+    ['promise', 'pendingExtras', 'didLoad'],
+    ['gen'],
+  );
 };
 
 module.exports = { isAbortError, createLoadCoordinator };

package/lib/session/navigation.js

@@ -12,6 +12,8 @@ const initialState = (options = {}) => ({
   scroll: 0,
   listScroll: 0,
   reviewPath: null,
+  fileScope: 'diff',
+  unitLine: 0,
   selection: null,
   mouseAnchor: null,
   pendingClick: null,
@@ -30,11 +32,20 @@ const clampIndex = (nav, length) => {
 
 const current = (nav, items, todoItem) => {
   if (nav.todoOpen) return todoItem;
+  if (nav.pane === 'unit' && nav.reviewPath) {
+    const item = items[nav.index];
+    if (item && listPath(item) === nav.reviewPath) return item;
+    for (const entry of items) {
+      if (listPath(entry) === nav.reviewPath) return entry;
+    }
+    return null;
+  }
   return items[nav.index] ?? null;
 };
 
 const syncReviewPath = (nav, item) => {
-  if (nav.pane !== 'diff') return;
+  if (nav.pane !== 'diff' && nav.pane !== 'unit') return;
+  if (nav.pane === 'unit' && nav.reviewPath) return;
   nav.reviewPath = item ? listPath(item) : null;
 };
 

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