reslop 0.2.3 → 0.2.5

package/lib/session/lifecycle.js

@@ -3,14 +3,18 @@
 const fs = require('node:fs');
 const path = require('node:path');
 
-const { isAbortError } = require('./load.js');
-const { createDiskWatcher, POLL_MS, DEBOUNCE_MS } = require('./watch.js');
+const sessionLoad = require('./load.js');
+const { isAbortError, tagLoaded, fetchSnapshot, fetchExtras } = sessionLoad;
+const watch = require('./watch.js');
+const { createDiskWatcher, DEBOUNCE_MS } = watch;
 const files = require('../files.js');
-const { itemPath, relativeAge, TODO_FILE } = files;
-const { MANIFEST, LOCKFILE, depFileMeta } = require('../deps.js');
+const { itemPath, relativeAge } = files;
+const deps = require('../deps.js');
+const { MANIFEST, LOCKFILE, depFileMeta } = deps;
 const review = require('../review.js');
 const { hasNotes, loadReview } = review;
-const { mergeReview } = require('../review-merge.js');
+const reviewMerge = require('../review-merge.js');
+const { mergeReview } = reviewMerge;
 
 const loadOptions = (api, extra = {}) => {
   const { loadConfig, ui } = api;
@@ -78,7 +82,7 @@ const failOpen = (api, error) => {
 
 const restoreAfterLoad = (api, here, wasTodo) => {
   const { collection, nav, ui } = api;
-  nav.todoOpen = wasTodo;
+  nav.tasksOpen = wasTodo;
   if (here && !wasTodo) {
     const idx = collection.findRestoredIndex(here);
     if (idx >= 0) nav.index = idx;
@@ -148,7 +152,7 @@ const applyLoaded = (api, loaded) => {
   if (loaded.generation !== undefined) {
     if (!loader.accept(loaded.generation, ui.done)) return false;
   }
-  const wasTodo = nav.todoOpen === true;
+  const wasTodo = nav.tasksOpen === true;
   const here = ui.current();
   ui.top = loaded.top ?? api.loadConfig.cwd;
   collection.replace(loaded.items);
@@ -239,6 +243,13 @@ const clearNpmExtras = (api) => {
   api.npmExtras = null;
 };
 
+const isWanted = (api, gen) => {
+  if (!api.loader.isCurrent(gen)) return false;
+  if (!api.ui.done) return true;
+  api.ops.clearBusy();
+  return false;
+};
+
 const followExtras = async (api, loaded, gen, kind) => {
   const extra = loadOptions(api, {
     paths: api.loadConfig.paths,
@@ -246,25 +257,18 @@ const followExtras = async (api, loaded, gen, kind) => {
   });
   let next;
   try {
-    next = await api.loader.fetchExtras(api.loadConfig.repo, loaded, extra);
+    next = await fetchExtras(api.loadConfig.repo, loaded, extra);
   } catch (error) {
-    if (!api.loader.isCurrent(gen)) return;
-    return void failOpen(api, error);
-  }
-  if (!api.loader.isCurrent(gen)) return;
-  if (api.ui.done) {
-    api.ops.clearBusy();
+    if (api.loader.isCurrent(gen)) failOpen(api, error);
     return;
   }
-  if (!next) {
-    api.ops.clearBusy();
+  if (!isWanted(api, gen)) return;
+  if (next) {
+    applyLoaded(api, tagLoaded(next, gen));
+    cacheNpmExtras(api, next);
+  } else {
     api.loader.pendingExtras = false;
-    api.ui.paint();
-    finishIfEmpty(api, kind);
-    return;
   }
-  applyLoaded(api, api.loader.tag(next, gen));
-  cacheNpmExtras(api, next);
   api.ops.clearBusy();
   api.ui.paint();
   finishIfEmpty(api, kind);
@@ -297,7 +301,13 @@ const resetNavAfterLoad = (api, extra = {}) => {
   if (extra.afterLoad) extra.afterLoad();
 };
 
+const refreshListsForPane = (api) => {
+  const pane = api.ui.nav.pane;
+  if (pane === 'commits' && api.ui.commits) api.ui.commits.refresh();
+};
+
 const afterSnapshot = (api, kind, extra = {}) => {
+  refreshListsForPane(api);
   if (kind !== 'open' && kind !== 'watch') {
     return void resetNavAfterLoad(api, extra);
   }
@@ -315,7 +325,7 @@ const runSnapshot = async (api, gen, kind, extra = {}) => {
   beginSnapshot(api, extra);
   let loaded;
   try {
-    loaded = await api.loader.fetchSnapshot(
+    loaded = await fetchSnapshot(
       api.loadConfig.repo,
       api.loadConfig.cwd,
       api.loadConfig.paths,
@@ -325,15 +335,11 @@ const runSnapshot = async (api, gen, kind, extra = {}) => {
       }),
     );
   } catch (error) {
-    if (!api.loader.isCurrent(gen)) return;
-    return void failOpen(api, error);
-  }
-  if (!api.loader.isCurrent(gen)) return;
-  if (api.ui.done) {
-    api.ops.clearBusy();
+    if (api.loader.isCurrent(gen)) failOpen(api, error);
     return;
   }
-  applyLoaded(api, api.loader.tag(loaded, gen));
+  if (!isWanted(api, gen)) return;
+  applyLoaded(api, tagLoaded(loaded, gen));
   afterSnapshot(api, kind, extra);
   if (loaded.pending === true || npmExtrasStale(api)) {
     api.ops.setBusy('checking npm');
@@ -379,7 +385,7 @@ const refreshFromRepo = (api, extra = {}) => {
     api.loadConfig.paths,
     snapshotOpts(api, extra),
   );
-  applyLoaded(api, api.loader.tag(loaded, gen));
+  applyLoaded(api, tagLoaded(loaded, gen));
   afterSnapshot(api, kind, extra);
   if (loaded.pending === true || npmExtrasStale(api)) {
     api.ops.setBusy('checking npm');
@@ -463,59 +469,6 @@ const catchUpWatch = (api) => {
   refreshFromRepo(api, { keepView: true, quiet: true });
 };
 
-const stampFile = (root, rel) => {
-  const full = path.join(root, rel);
-  let stat;
-  try {
-    stat = fs.statSync(full);
-  } catch {
-    return `${rel}:missing`;
-  }
-  return `${rel}:${stat.mtimeMs}:${stat.size}`;
-};
-
-const worktreeStamp = (api) => {
-  const root = api.ui.top || api.loadConfig.cwd;
-  const parts = [];
-  for (const rel of itemRels(api.collection)) {
-    if (!rel || rel === TODO_FILE) continue;
-    parts.push(stampFile(root, rel));
-  }
-  return parts.join('\n');
-};
-
-const watchesWorktree = (nav) =>
-  nav.todoOpen === true ||
-  nav.pane === 'branches' ||
-  nav.pane === 'commits' ||
-  nav.pane === 'npm';
-
-const currentFileStamp = (api) => {
-  const { nav } = api;
-  const root = api.ui.top || api.loadConfig.cwd;
-  if (watchesWorktree(nav)) return worktreeStamp(api);
-  const pane = nav.pane;
-  if (pane !== 'diff' && pane !== 'unit') return '';
-  const rel = pane === 'unit' ? nav.reviewPath : itemPath(api.ui.current());
-  if (!rel) return '';
-  return stampFile(root, rel);
-};
-
-const pollCurrentFile = (api) => {
-  const stamp = currentFileStamp(api);
-  if (!stamp) {
-    api.watchStamp = '';
-    return;
-  }
-  if (!api.watchStamp) {
-    api.watchStamp = stamp;
-    return;
-  }
-  if (stamp === api.watchStamp) return;
-  api.watchStamp = stamp;
-  onDiskChange(api);
-};
-
 const reviewFileStamp = (api) => {
   const store = api.review && api.review.store;
   if (!store || !store.reviewPath) return '';
@@ -549,14 +502,12 @@ const applyReviewChange = (api) => {
   }
   mergeReview(store, disk);
   api.reviewStamp = stamp;
-  if (typeof api.ui.paint === 'function') api.ui.paint();
+  api.ui.paint();
 };
 
 const stopWatch = (api) => {
   clearWatchRetry(api);
-  api.watchStamp = '';
   api.reviewStamp = '';
-  if (api.ui.term) api.ui.term.stopTimer('watch');
   if (!api.diskWatcher) return;
   api.diskWatcher.close();
   api.diskWatcher = null;
@@ -575,26 +526,15 @@ const startWatch = (api) => {
   });
   syncItemWatches(api);
   noteReviewStamp(api);
-  if (!api.ui.term) return;
-  api.ui.term.startTimer(
-    'watch',
-    () => {
-      pollCurrentFile(api);
-      applyReviewChange(api);
-    },
-    POLL_MS,
-  );
 };
 
 const createLifecycle = (api) => {
   api.diskWatcher = null;
   api.watchRetry = null;
-  api.watchStamp = '';
   api.reviewStamp = '';
   api.ignoreWatchUntil = 0;
   api.npmExtras = null;
   return {
-    applyLoaded: (loaded) => applyLoaded(api, loaded),
     load: () => load(api),
     openLoad: () => openLoad(api),
     loadReady: () => loadReady(api),
@@ -605,7 +545,6 @@ const createLifecycle = (api) => {
     applyReviewChange: () => applyReviewChange(api),
     noteReviewStamp: () => noteReviewStamp(api),
     catchUpWatch: () => catchUpWatch(api),
-    pollCurrentFile: () => pollCurrentFile(api),
     startWatch: () => startWatch(api),
     stopWatch: () => stopWatch(api),
     ignoreWatch: (ms) => ignoreWatch(api, ms),

package/lib/session/load.js

@@ -1,71 +1,66 @@
 'use strict';
 
-const { stateView } = require('./accessors.js');
+const utilities = require('../utilities.js');
+const { isAbort: isAbortError } = utilities;
 
-const isAbortError = (error) => !!(error && error.code === 'ABORT');
+class LoadCoordinator {
+  constructor() {
+    this.gen = 0;
+    this.abortController = null;
+    this.promise = null;
+    this.pendingExtras = false;
+    this.didLoad = false;
+  }
 
-const createLoadCoordinator = () => {
-  const state = {
-    gen: 0,
-    abort: null,
-    promise: null,
-    pendingExtras: false,
-    didLoad: false,
-  };
+  get signal() {
+    return this.abortController?.signal;
+  }
 
-  const bump = () => {
-    state.gen += 1;
-    state.abort?.abort();
-    state.abort = new AbortController();
-    return state.gen;
-  };
+  bump() {
+    this.gen += 1;
+    this.abortController?.abort();
+    this.abortController = new AbortController();
+    return this.gen;
+  }
 
-  const isCurrent = (gen, done = false) => gen === state.gen && !done;
-  const accept = isCurrent;
+  isCurrent(gen, done = false) {
+    return gen === this.gen && !done;
+  }
 
-  const abort = () => {
-    state.abort?.abort();
-  };
+  accept(gen, done = false) {
+    return this.isCurrent(gen, done);
+  }
 
-  const reset = () => {
-    abort();
-    state.gen += 1;
-    state.abort = null;
-    state.promise = null;
-    state.pendingExtras = false;
-    state.didLoad = false;
-  };
+  abort() {
+    this.abortController?.abort();
+  }
 
-  const tag = (loaded, gen) => ({ ...loaded, generation: gen });
+  reset() {
+    this.abort();
+    this.gen += 1;
+    this.abortController = null;
+    this.promise = null;
+    this.pendingExtras = false;
+    this.didLoad = false;
+  }
+}
 
-  const fetchSnapshot = async (repo, cwd, paths, options) => {
-    if (repo.loadAsync) return repo.loadAsync(cwd, paths, options);
-    return repo.load(cwd, paths, options);
-  };
+const tagLoaded = (loaded, gen) => ({ ...loaded, generation: gen });
 
-  const fetchExtras = async (repo, loaded, extra) => {
-    if (!repo.loadExtras) return null;
-    return repo.loadExtras(loaded, extra);
-  };
+const fetchSnapshot = async (repo, cwd, paths, options) => {
+  if (repo.loadAsync) return repo.loadAsync(cwd, paths, options);
+  return repo.load(cwd, paths, options);
+};
 
-  return stateView(
-    state,
-    {
-      get signal() {
-        return state.abort?.signal;
-      },
-      bump,
-      isCurrent,
-      accept,
-      abort,
-      reset,
-      tag,
-      fetchSnapshot,
-      fetchExtras,
-    },
-    ['promise', 'pendingExtras', 'didLoad'],
-    ['gen'],
-  );
+const fetchExtras = async (repo, loaded, extra) => {
+  if (!repo.loadExtras) return null;
+  return repo.loadExtras(loaded, extra);
 };
 
-module.exports = { isAbortError, createLoadCoordinator };
+module.exports = {
+  isAbortError,
+  LoadCoordinator,
+  tagLoaded,
+  fetchSnapshot,
+  fetchExtras,
+};

package/lib/session/navigation.js

@@ -1,106 +1,116 @@
 'use strict';
 
 const files = require('../files.js');
-const { listPath, isTodoItem, isTodosEntry, TODO_FILE } = files;
-
-const initialState = (options = {}) => ({
-  pane: options.startPane ?? 'files',
-  index: 0,
-  fileCursor: 0,
-  branchCursor: 0,
-  commitCursor: 0,
-  npmCursor: 0,
-  scroll: 0,
-  listScroll: 0,
-  reviewPath: null,
-  fileScope: 'diff',
-  unitLine: 0,
-  selection: null,
-  mouseAnchor: null,
-  pendingClick: null,
-  todoOpen: false,
-  todoFocus: 0,
-});
-
-const clampIndex = (nav, length) => {
-  if (!length) {
-    nav.index = 0;
-    return;
+const { listPath, isTaskItem, isTasksEntry, TASKS_FILE } = files;
+
+const LIST_PANES = ['files', 'branches', 'commits', 'npm'];
+
+const freshListScroll = () =>
+  Object.fromEntries(LIST_PANES.map((pane) => [pane, 0]));
+
+class Navigation {
+  constructor(options = {}) {
+    this.reset(options.startPane ?? 'files');
   }
-  if (nav.index < 0) nav.index = 0;
-  if (nav.index >= length) nav.index = length - 1;
-};
-
-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;
+
+  reset(startPane = this.pane) {
+    this.pane = startPane;
+    this.index = 0;
+    this.fileCursor = 0;
+    this.branchCursor = 0;
+    this.commitCursor = 0;
+    this.npmCursor = 0;
+    this.scroll = 0;
+    this.listScrollByPane = freshListScroll();
+    this.reviewPath = null;
+    this.fileScope = 'diff';
+    this.unitLine = 0;
+    this.selection = null;
+    this.mouseAnchor = null;
+    this.pendingClick = null;
+    this.lastClick = null;
+    this.tasksOpen = false;
+    this.tasksFocus = 0;
+  }
+
+  clampIndex(length) {
+    if (!length) {
+      this.index = 0;
+      return;
     }
-    return null;
+    if (this.index < 0) this.index = 0;
+    if (this.index >= length) this.index = length - 1;
   }
-  return items[nav.index] ?? null;
-};
-
-const syncReviewPath = (nav, item) => {
-  if (nav.pane !== 'diff' && nav.pane !== 'unit') return;
-  if (nav.pane === 'unit' && nav.reviewPath) return;
-  nav.reviewPath = item ? listPath(item) : null;
-};
-
-const clampFileCursor = (nav, length) => {
-  if (!length) {
-    nav.fileCursor = 0;
-    return;
+
+  current(items, tasksItem) {
+    if (this.tasksOpen) return tasksItem;
+    if (this.pane === 'unit' && this.reviewPath) {
+      const item = items[this.index];
+      if (item && listPath(item) === this.reviewPath) return item;
+      for (const entry of items) {
+        if (listPath(entry) === this.reviewPath) return entry;
+      }
+      return null;
+    }
+    return items[this.index] ?? null;
   }
-  if (nav.fileCursor >= length) nav.fileCursor = length - 1;
-};
 
-const followReviewPath = (nav, fileList, item) => {
-  if (!fileList.length) {
-    nav.fileCursor = 0;
-    return;
+  syncReviewPath(item) {
+    if (this.pane !== 'diff' && this.pane !== 'unit') return;
+    if (this.pane === 'unit' && this.reviewPath) return;
+    this.reviewPath = item ? listPath(item) : null;
   }
-  let idx = fileList.findIndex(
-    (entry) => !isTodosEntry(entry) && entry.path === nav.reviewPath,
-  );
-  if (nav.reviewPath === TODO_FILE || isTodoItem(item)) {
-    idx = fileList.findIndex((entry) => isTodosEntry(entry));
+
+  clampFileCursor(length) {
+    if (!length) {
+      this.fileCursor = 0;
+      return;
+    }
+    if (this.fileCursor >= length) this.fileCursor = length - 1;
   }
-  if (idx >= 0) {
-    nav.fileCursor = idx;
-    return;
+
+  followReviewPath(fileList, item) {
+    if (!fileList.length) {
+      this.fileCursor = 0;
+      return;
+    }
+    let idx = fileList.findIndex(
+      (entry) => !isTasksEntry(entry) && entry.path === this.reviewPath,
+    );
+    if (this.reviewPath === TASKS_FILE || isTaskItem(item)) {
+      idx = fileList.findIndex((entry) => isTasksEntry(entry));
+    }
+    if (idx >= 0) {
+      this.fileCursor = idx;
+      return;
+    }
+    this.clampFileCursor(fileList.length);
+  }
+
+  restoreFileCursor(fileList) {
+    if (this.pane !== 'files') return;
+    this.followReviewPath(fileList, null);
+  }
+
+  clearSelection() {
+    this.selection = null;
+    this.mouseAnchor = null;
+    this.pendingClick = null;
+  }
+
+  get listScroll() {
+    return this.listScrollByPane[this.pane] ?? 0;
+  }
+
+  set listScroll(value) {
+    if (!LIST_PANES.includes(this.pane)) return;
+    this.listScrollByPane[this.pane] = value ?? 0;
   }
-  clampFileCursor(nav, fileList.length);
-};
-
-const restoreFileCursor = (nav, fileList) => {
-  if (nav.pane !== 'files') return;
-  followReviewPath(nav, fileList, null);
-};
-
-const clearSelection = (nav) => {
-  nav.selection = null;
-  nav.mouseAnchor = null;
-  nav.pendingClick = null;
-};
-
-const createNavigation = (options = {}) => {
-  const nav = initialState(options);
-  nav.reset = (startPane) => {
-    const pane = startPane ?? nav.pane;
-    Object.assign(nav, initialState({ startPane: pane }));
-  };
-  nav.clampIndex = (length) => clampIndex(nav, length);
-  nav.current = (items, todoItem) => current(nav, items, todoItem);
-  nav.syncReviewPath = (item) => syncReviewPath(nav, item);
-  nav.clampFileCursor = (length) => clampFileCursor(nav, length);
-  nav.followReviewPath = (list, item) => followReviewPath(nav, list, item);
-  nav.restoreFileCursor = (list) => restoreFileCursor(nav, list);
-  nav.clearSelection = () => clearSelection(nav);
-  return nav;
-};
-
-module.exports = { createNavigation };
+
+  resetListScroll(pane = this.pane) {
+    if (!LIST_PANES.includes(pane)) return;
+    this.listScrollByPane[pane] = 0;
+  }
+}
+
+module.exports = { Navigation };