reslop 0.1.9 → 0.2.1

package/lib/session/update.js

@@ -1,10 +1,12 @@
 'use strict';
 
+const { stateView } = require('./accessors.js');
+
 const update = require('../update.js');
 const { checkUpdate, installUpdate, markSkipped } = update;
 
 const optsOf = (api) => {
-  const value = api.options.updateOpts();
+  const value = api.ui.updateOpts;
   if (!value || value === true) return {};
   return value;
 };
@@ -19,15 +21,16 @@ const reset = (state) => {
 
 const maybePrompt = (api) => {
   if (!api.state.offer) return;
-  if (!api.options.didLoad()) return;
-  if (api.options.getMode() !== 'review') return;
-  api.options.setMode('confirmUpdate');
+  if (!api.ui.loader.didLoad) return;
+  if (api.ui.mode !== 'review') return;
+  api.ui.mode = 'confirmUpdate';
 };
 
 const runInstall = async (api, version) => {
-  api.options.setStatus('updating reslop');
-  api.options.startInstallProgress();
-  api.options.paint();
+  api.ui.status = 'updating reslop';
+  api.ui.progressFrame = 0;
+  api.ui.progress.start('install');
+  api.ui.paint();
   let ok = false;
   try {
     await installUpdate(version, optsOf(api));
@@ -35,23 +38,23 @@ const runInstall = async (api, version) => {
   } catch {
     // ignore install errors
   }
-  api.options.stopInstallProgress();
-  if (api.options.isDone() || !api.options.uiOpen()) return;
-  api.options.setStatus(ok ? 'updated' : 'update failed');
-  api.options.paint();
+  api.ui.progress.stop('install');
+  if (api.ui.done || !api.ui.uiOpen) return;
+  api.ui.status = ok ? 'updated' : 'update failed';
+  api.ui.paint();
 };
 
 const acceptUpdate = (api) => {
-  api.options.setMode('review');
+  api.ui.mode = 'review';
   api.state.offer = false;
   const version = api.state.to;
   api.state.installPromise = runInstall(api, version);
 };
 
 const declineUpdate = (api) => {
-  api.options.setMode('review');
+  api.ui.mode = 'review';
   api.state.offer = false;
-  api.options.setStatus('');
+  api.ui.status = '';
   markSkipped(api.state.to, optsOf(api));
 };
 
@@ -62,7 +65,7 @@ const runOpenUpdate = async (api) => {
   } catch {
     return;
   }
-  if (api.options.isDone()) return;
+  if (api.ui.done) return;
   if (plan.action === 'install') {
     api.state.installPromise = runInstall(api, plan.latest);
     await api.state.installPromise;
@@ -73,17 +76,17 @@ const runOpenUpdate = async (api) => {
   api.state.to = plan.latest;
   api.state.offer = true;
   maybePrompt(api);
-  api.options.paint();
+  api.ui.paint();
 };
 
 const openUpdate = (api) => {
-  if (api.options.updateOpts() === false) return Promise.resolve();
+  if (api.ui.updateOpts === false) return Promise.resolve();
   if (api.state.checkPromise) return api.state.checkPromise;
   api.state.checkPromise = runOpenUpdate(api);
   return api.state.checkPromise;
 };
 
-const createUpdateCoordinator = (options) => {
+const createUpdateCoordinator = (ui) => {
   const state = {
     offer: false,
     from: '',
@@ -91,35 +94,19 @@ const createUpdateCoordinator = (options) => {
     checkPromise: null,
     installPromise: null,
   };
-  const api = { options, state };
-  return {
-    get offer() {
-      return state.offer;
-    },
-    set offer(value) {
-      state.offer = value;
-    },
-    get from() {
-      return state.from;
-    },
-    get to() {
-      return state.to;
+  const api = { ui, state };
+  return stateView(
+    state,
+    {
+      reset: () => reset(state),
+      maybePrompt: () => maybePrompt(api),
+      accept: () => acceptUpdate(api),
+      decline: () => declineUpdate(api),
+      open: () => openUpdate(api),
     },
-    get checkPromise() {
-      return state.checkPromise;
-    },
-    get installPromise() {
-      return state.installPromise;
-    },
-    set installPromise(value) {
-      state.installPromise = value;
-    },
-    reset: () => reset(state),
-    maybePrompt: () => maybePrompt(api),
-    accept: () => acceptUpdate(api),
-    decline: () => declineUpdate(api),
-    open: () => openUpdate(api),
-  };
+    ['offer', 'installPromise'],
+    ['from', 'to', 'checkPromise'],
+  );
 };
 
 module.exports = { createUpdateCoordinator };

package/lib/session/view.js

@@ -6,11 +6,8 @@ const files = require('../files.js');
 const { fileEntries, REPO_TODOS_LABEL } = files;
 const review = require('../review.js');
 const { noteCounts } = review;
-
-const SOURCE_KIND = {
-  'github-pr': 'pr',
-  'gitlab-mr': 'mr',
-};
+const diff = require('../diff/diff.js');
+const { unitLines, itemsForPath, splitEditor, mergeEditRows } = diff;
 
 const relabelStatus = (entries, from, to) => {
   if (!to) return entries;
@@ -43,14 +40,60 @@ const todosEntry = (counts) => ({
   unstaged: 0,
 });
 
+const blankEntry = (rel) => ({
+  path: rel,
+  origins: [],
+  firstIndex: 0,
+  openIndex: 0,
+  remaining: 0,
+  added: 0,
+  removed: 0,
+  stagedAdded: 0,
+  stagedRemoved: 0,
+  unstagedAdded: 0,
+  unstagedRemoved: 0,
+  staged: 0,
+  unstaged: 0,
+  date: '',
+  status: '',
+});
+
+const listedNames = (api) => {
+  const repo = api.ui.repo;
+  if (!repo || typeof repo.listFiles !== 'function') return [];
+  try {
+    return repo.listFiles(api.ui.top || api.ui.cwd, api.ui.paths ?? [], {
+      commit: api.ui.rev,
+    });
+  } catch {
+    return [];
+  }
+};
+
+const mergeUnitFiles = (entries, names) => {
+  const have = new Set();
+  for (const entry of entries) have.add(entry.path);
+  const extra = [];
+  for (const rel of names) {
+    if (!rel || have.has(rel)) continue;
+    extra.push(blankEntry(rel));
+  }
+  const merged = [...entries, ...extra];
+  merged.sort((left, right) => left.path.localeCompare(right.path, 'en'));
+  return merged;
+};
+
 const fileList = (api, notes = noteCounts(api.review.store)) => {
   const entries = fileEntries(api.collection.items);
   const sourceLabel = api.ui.sourceLabel;
   const from = sourceLabel ? 'pr' : 'commit';
   const to = sourceLabel || api.ui.revShort;
   const labeled = relabelStatus(entries, from, to);
-  labeled.unshift(todosEntry(notes));
-  return labeled;
+  const names = listedNames(api);
+  const scoped =
+    api.nav.fileScope === 'file' ? mergeUnitFiles(labeled, names) : labeled;
+  scoped.unshift(todosEntry(notes));
+  return scoped;
 };
 
 const counts = (api, notes = noteCounts(api.review.store)) => {
@@ -76,11 +119,34 @@ const counts = (api, notes = noteCounts(api.review.store)) => {
 
 const viewStatus = (api) => api.ui.status || api.ui.busy;
 
+const unitFileText = (api) => {
+  const rel = api.nav.reviewPath;
+  if (!rel) return '';
+  const repo = api.ui.repo;
+  if (repo && typeof repo.fileText === 'function') {
+    return repo.fileText(api.ui.top, rel, api.ui.rev);
+  }
+  return '';
+};
+
+const unitBodyLines = (api) => {
+  if (api.nav.pane !== 'unit') return [];
+  const rel = api.nav.reviewPath;
+  const group = itemsForPath(api.collection.items, rel);
+  const live = api.composer.liveFileText();
+  if (live !== null) {
+    const base = api.composer.fileEditRows();
+    if (base && base.length) return mergeEditRows(base, splitEditor(live));
+    return mergeEditRows(unitLines(live, group), splitEditor(live));
+  }
+  return unitLines(unitFileText(api), group);
+};
+
 const view = (api) => {
   const { composer, nav, ui, gitBranches, commits, updater } = api;
   const templates = composer.shownTemplates();
   const change = ui.change;
-  const sourceKind = (change && SOURCE_KIND[change.source]) || '';
+  const sourceKind = (change && change.source) || '';
   const notes = noteCounts(api.review.store);
   return {
     item: ui.current(),
@@ -94,9 +160,12 @@ const view = (api) => {
     counts: counts(api, notes),
     selection: nav.selection,
     pane: nav.pane,
+    fileScope: nav.fileScope,
     files: fileList(api, notes),
     fileCursor: nav.fileCursor,
     reviewPath: nav.reviewPath,
+    unitLine: nav.unitLine,
+    unitLines: unitBodyLines(api),
     branch: ui.branch,
     branches: gitBranches.branches,
     branchCursor: nav.branchCursor,
@@ -128,4 +197,4 @@ const createView = (api) => ({
   view: () => view(api),
 });
 
-module.exports = { SOURCE_KIND, relabelStatus, createView };
+module.exports = { relabelStatus, createView };

package/lib/session/watch.js

@@ -72,25 +72,127 @@ const closeWatcher = (watcher) => {
   }
 };
 
-const schedule = (state) => {
-  if (state.closed) return;
-  if (state.timer !== null) state.clearTimeoutFn(state.timer);
-  state.timer = state.setTimeoutFn(() => {
-    state.timer = null;
+const reviewMarkdown = (rel) => {
+  const norm = `${rel}`.replaceAll('\\', '/');
+  if (!norm.startsWith('.review/')) return false;
+  const rest = norm.slice('.review/'.length);
+  if (!rest || rest.includes('/')) return false;
+  return rest.endsWith('.md');
+};
+
+const isReviewDir = (root, dir) => {
+  const rel = path.relative(root, dir).replaceAll('\\', '/');
+  return rel === '.review' || rel.startsWith('.review/');
+};
+
+const hasFile = (full) => {
+  try {
+    fs.accessSync(full);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const isBareReviewName = (root, dir, rel) => {
+  if (!rel || rel.includes('/') || !rel.endsWith('.md')) return false;
+  const base = path.basename(rel);
+  if (hasFile(path.join(dir, base))) return false;
+  return hasFile(path.join(root, '.review', base));
+};
+
+const isReviewEvent = (root, dir, name) => {
+  if (isReviewDir(root, dir)) return true;
+  if (!name) return false;
+  const rel = path.relative(root, path.join(dir, name));
+  const norm = rel.replaceAll('\\', '/');
+  if (reviewMarkdown(norm)) return true;
+  return isBareReviewName(root, dir, norm);
+};
+
+const isOwnDirEvent = (dir, name) => {
+  if (!name) return false;
+  const base = path.basename(dir);
+  const slash = `${name}`.replaceAll('\\', '/');
+  const bare = slash.startsWith('./') ? slash.slice(2) : slash;
+  const trimmed = bare.endsWith('/') ? bare.slice(0, -1) : bare;
+  if (trimmed === base) {
+    try {
+      return !fs.statSync(path.join(dir, trimmed)).isFile();
+    } catch {
+      return true;
+    }
+  }
+  const full = path.resolve(dir, name);
+  if (full === path.resolve(dir)) return true;
+  if (path.basename(full) !== base) return false;
+  try {
+    return fs.realpathSync(full) === fs.realpathSync(dir);
+  } catch {
+    return false;
+  }
+};
+
+const schedule = (state, timerKey, fire) => {
+  if (state.closed || !fire) return;
+  if (state[timerKey] !== null) clearTimeout(state[timerKey]);
+  state[timerKey] = setTimeout(() => {
+    state[timerKey] = null;
     if (state.closed) return;
-    state.onChange();
+    fire();
   }, state.debounceMs);
+  const timer = state[timerKey];
+  if (timer && typeof timer.unref === 'function') timer.unref();
+};
+
+const REVIEW_HOLD_MS = 200;
+
+const reviewBurst = (state) => {
+  const seen = state.reviewSeenAt;
+  if (!seen) return false;
+  const hold = Math.max(state.debounceMs * 2, REVIEW_HOLD_MS);
+  return Date.now() - seen < hold;
+};
+
+const scheduleChange = (state) => {
+  schedule(state, 'timer', () => {
+    if (reviewBurst(state)) return;
+    if (state.onChange) state.onChange();
+  });
+};
+
+const scheduleUnnamed = (state) => {
+  if (reviewBurst(state)) return;
+  schedule(state, 'looseTimer', () => {
+    if (reviewBurst(state)) return;
+    scheduleChange(state);
+  });
+};
+
+const dropChange = (state) => {
+  if (state.timer !== null) clearTimeout(state.timer);
+  if (state.looseTimer !== null) clearTimeout(state.looseTimer);
+  state.timer = null;
+  state.looseTimer = null;
 };
 
 const handleWatchEvent = (state, dir, eventType, filename) => {
   if (state.closed) return;
   const name = filename ? `${filename}` : '';
   const rel = name ? path.relative(state.root, path.join(dir, name)) : '';
+  if (isReviewEvent(state.root, dir, name)) {
+    state.reviewSeenAt = Date.now();
+    dropChange(state);
+    return void schedule(state, 'reviewTimer', state.onReview);
+  }
   if (rel && ignoredRel(rel)) return;
+  if (reviewBurst(state)) return;
+  if (!name) return void scheduleUnnamed(state);
+  if (isOwnDirEvent(dir, name)) return;
   if (eventType === 'rename' && name) {
     state.watchNewDir(path.join(dir, name));
   }
-  schedule(state);
+  scheduleChange(state);
 };
 
 const watchOne = (state, target, extra = {}) => {
@@ -100,9 +202,9 @@ const watchOne = (state, target, extra = {}) => {
     const onEvent = (eventType, filename) => {
       handleWatchEvent(state, target, eventType, filename);
     };
-    const watcher = state.watchFn(
+    const watcher = fs.watch(
       target,
-      { persistent: true, encoding: 'utf8', ...extra },
+      { persistent: false, encoding: 'utf8', ...extra },
       onEvent,
     );
     if (typeof watcher.on === 'function') {
@@ -120,7 +222,7 @@ const watchTree = (state, dir) => {
   if (state.recursive) return;
   let entries;
   try {
-    entries = state.readdirSync(dir, { withFileTypes: true });
+    entries = fs.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -135,11 +237,12 @@ const maybeWatchNewDir = (state, full) => {
   if (state.recursive) return;
   let stat;
   try {
-    stat = state.statSync(full);
+    stat = fs.statSync(full);
   } catch {
     return;
   }
   if (!stat.isDirectory()) return;
+  if (path.basename(full) === '.review') return void watchOne(state, full);
   if (skipDirName(path.basename(full))) return;
   watchTree(state, full);
 };
@@ -148,15 +251,11 @@ const watchScope = (state, spec) => {
   const target = path.resolve(state.root, spec);
   let stat;
   try {
-    stat = state.statSync(target);
+    stat = fs.statSync(target);
   } catch {
-    watchOne(state, path.dirname(target));
-    return;
-  }
-  if (stat.isDirectory()) {
-    watchTree(state, target);
-    return;
+    return void watchOne(state, path.dirname(target));
   }
+  if (stat.isDirectory()) return void watchTree(state, target);
   watchOne(state, path.dirname(target));
 };
 
@@ -168,8 +267,12 @@ const watchGit = (state) => {
 
 const stopState = (state) => {
   state.closed = true;
-  if (state.timer !== null) state.clearTimeoutFn(state.timer);
+  if (state.timer !== null) clearTimeout(state.timer);
+  if (state.reviewTimer !== null) clearTimeout(state.reviewTimer);
+  if (state.looseTimer !== null) clearTimeout(state.looseTimer);
   state.timer = null;
+  state.reviewTimer = null;
+  state.looseTimer = null;
   while (state.watchers.length) closeWatcher(state.watchers.pop());
   state.watched.clear();
 };
@@ -186,24 +289,24 @@ const createDiskWatcher = (options) => {
   const recursive = options.recursive ?? canWatchRecursive();
   const state = {
     root: path.resolve(options.root),
-    watchFn: options.watch ?? fs.watch,
-    readdirSync: options.readdirSync ?? fs.readdirSync,
-    statSync: options.statSync ?? fs.statSync,
-    setTimeoutFn: options.setTimeout ?? setTimeout,
-    clearTimeoutFn: options.clearTimeout ?? clearTimeout,
     debounceMs: options.debounceMs ?? DEBOUNCE_MS,
     onChange: options.onChange,
     recursive,
     dirWatchOpts: recursive ? { recursive: true } : {},
     watchers: [],
     watched: new Set(),
+    onReview: options.onReview,
     timer: null,
+    reviewTimer: null,
+    looseTimer: null,
+    reviewSeenAt: 0,
     closed: false,
     watchNewDir: (full) => maybeWatchNewDir(state, full),
   };
   const scopes = options.paths && options.paths.length ? options.paths : ['.'];
   for (const spec of scopes) watchScope(state, spec);
   watchGit(state);
+  watchOne(state, path.resolve(state.root, '.review'));
   return {
     close: () => stopState(state),
     watchFiles: (rels) => watchFiles(state, rels),
@@ -215,5 +318,6 @@ module.exports = {
   POLL_MS,
   canWatchRecursive,
   ignoredRel,
+  isOwnDirEvent,
   createDiskWatcher,
 };