reslop 0.2.5 → 0.2.7

package/lib/session/watch.js

@@ -3,7 +3,12 @@
 const fs = require('node:fs');
 const path = require('node:path');
 
+const runs = require('../runs.js');
+const { isRunsRel } = runs;
+
 const DEBOUNCE_MS = 200;
+const UNKNOWN_PATH = '.';
+const MODULES_STAMP = 'node_modules/.package-lock.json';
 
 const SKIP_DIRS = ['node_modules', '.review', 'coverage', 'dist', '.cache'];
 
@@ -14,41 +19,30 @@ const GIT_WATCH_NAMES = [
   'FETCH_HEAD',
   'ORIG_HEAD',
   'refs',
+  'rebase-merge',
+  'rebase-apply',
 ];
 
-const linuxRecursiveNode = (version) => {
-  const parts = `${version}`.split('.');
-  const major = Number(parts[0]);
-  const minor = Number(parts[1]);
-  if (major > 19) return true;
-  return major === 19 && minor >= 1;
-};
-
 const canWatchRecursive = (
   platform = process.platform,
   version = process.versions.node,
 ) => {
   if (platform === 'win32' || platform === 'darwin') return true;
-  if (platform === 'linux') return linuxRecursiveNode(version);
-  return false;
+  if (platform !== 'linux') return false;
+  const [major, minor] = `${version}`.split('.').map(Number);
+  return major > 19 || (major === 19 && minor >= 1);
 };
 
-const ignoredName = (name) => {
-  if (!name) return false;
-  if (name.endsWith('.lock')) return true;
-  if (name.endsWith('~')) return true;
-  if (name.endsWith('.swp') || name.endsWith('.swo')) return true;
-  if (name.startsWith('.#')) return true;
-  if (name === '.DS_Store') return true;
-  return false;
-};
+const IGNORED_SUFFIXES = ['.lock', '~', '.swp', '.swo'];
 
-const ignoredGitRel = (parts) => {
-  if (parts[1] === 'logs' && parts[2] === 'HEAD') return false;
-  const name = parts[1] ?? '';
-  if (!name) return false;
-  if (GIT_WATCH_NAMES.includes(name)) return false;
-  return true;
+const ignoredName = (name) =>
+  IGNORED_SUFFIXES.some((suffix) => name.endsWith(suffix)) ||
+  name.startsWith('.#') ||
+  name === '.DS_Store';
+
+const ignoredGitRel = ([, name = '', sub]) => {
+  if (name === 'logs' && sub === 'HEAD') return false;
+  return name !== '' && !GIT_WATCH_NAMES.includes(name);
 };
 
 const slashRel = (rel) => `${rel}`.replaceAll('\\', '/');
@@ -56,34 +50,24 @@ const slashRel = (rel) => `${rel}`.replaceAll('\\', '/');
 const ignoredRel = (rel) => {
   const norm = slashRel(rel);
   if (!norm || norm === '.') return false;
+  if (norm === MODULES_STAMP) return false;
   const parts = norm.split('/');
-  for (const part of parts) {
-    if (SKIP_DIRS.includes(part)) return true;
-  }
+  if (parts.some((part) => SKIP_DIRS.includes(part))) return true;
   if (parts[0] === '.git') return ignoredGitRel(parts);
   return ignoredName(parts[parts.length - 1]);
 };
 
 const skipDirName = (name) => name === '.git' || SKIP_DIRS.includes(name);
 
-const closeWatcher = (watcher) => {
-  try {
-    watcher.close();
-  } catch {
-    // already closed
-  }
-};
-
 const reviewMarkdown = (rel) => {
-  const norm = `${rel}`.replaceAll('\\', '/');
-  if (!norm.startsWith('.review/')) return false;
-  const rest = norm.slice('.review/'.length);
+  if (!rel.startsWith('.review/')) return false;
+  const rest = rel.slice('.review/'.length);
   if (!rest || rest.includes('/')) return false;
   return rest.endsWith('.md');
 };
 
 const isReviewDir = (root, dir) => {
-  const rel = path.relative(root, dir).replaceAll('\\', '/');
+  const rel = slashRel(path.relative(root, dir));
   return rel === '.review' || rel.startsWith('.review/');
 };
 
@@ -106,16 +90,15 @@ const isBareReviewName = (root, dir, rel) => {
 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 rel = slashRel(path.relative(root, path.join(dir, name)));
+  if (reviewMarkdown(rel)) return true;
+  return isBareReviewName(root, dir, rel);
 };
 
 const isOwnDirEvent = (dir, name) => {
   if (!name) return false;
   const base = path.basename(dir);
-  const slash = `${name}`.replaceAll('\\', '/');
+  const slash = slashRel(name);
   const bare = slash.startsWith('./') ? slash.slice(2) : slash;
   const trimmed = bare.endsWith('/') ? bare.slice(0, -1) : bare;
   if (trimmed === base) {
@@ -144,200 +127,206 @@ const unchangedSince = (full, since) => {
   }
 };
 
-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;
-    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;
-};
+class DiskWatcher {
+  constructor(options) {
+    this.root = path.resolve(options.root);
+    this.debounceMs = options.debounceMs ?? DEBOUNCE_MS;
+    this.onChange = options.onChange;
+    this.onReview = options.onReview;
+    this.onPaths = options.onPaths;
+    this.matchReview = options.matchReview ?? null;
+    this.recursive = options.recursive ?? canWatchRecursive();
+    this.watchers = [];
+    this.watched = new Set();
+    this.files = new Set();
+    this.pending = new Set();
+    this.timers = { change: null, review: null, loose: null, paths: null };
+    this.looseChange = false;
+    this.reviewSeenAt = 0;
+    this.startedAt = Date.now();
+    this.closed = false;
+    const scopes = options.paths?.length ? options.paths : ['.'];
+    for (const spec of scopes) this.watchScope(spec);
+    const gitDir = path.resolve(this.root, '.git');
+    this.watchOne(gitDir);
+    this.watchOne(path.join(gitDir, 'refs'));
+    this.watchOne(path.join(gitDir, 'logs'));
+    this.watchOne(path.resolve(this.root, runs.runsDir('.')));
+    this.watchOne(path.resolve(this.root, '.review'));
+  }
 
-const scheduleChange = (state, loose = false) => {
-  state.looseChange = loose && (state.timer === null || state.looseChange);
-  schedule(state, 'timer', () => {
-    if (state.looseChange && reviewBurst(state)) return;
-    if (state.onChange) state.onChange();
-  });
-};
+  schedule(key, fire) {
+    if (this.closed || !fire) return;
+    this.clearTimer(key);
+    this.timers[key] = setTimeout(() => {
+      this.timers[key] = null;
+      if (!this.closed) fire();
+    }, this.debounceMs);
+    this.timers[key].unref();
+  }
 
-const scheduleUnnamed = (state) => {
-  if (reviewBurst(state)) return;
-  schedule(state, 'looseTimer', () => {
-    if (!reviewBurst(state)) scheduleChange(state, true);
-  });
-};
+  clearTimer(key) {
+    if (this.timers[key] !== null) clearTimeout(this.timers[key]);
+    this.timers[key] = null;
+  }
 
-const clearTimer = (state, timerKey) => {
-  if (state[timerKey] !== null) clearTimeout(state[timerKey]);
-  state[timerKey] = null;
-};
+  reviewBurst() {
+    if (!this.reviewSeenAt) return false;
+    const hold = Math.max(this.debounceMs * 2, REVIEW_HOLD_MS);
+    return Date.now() - this.reviewSeenAt < hold;
+  }
 
-const dropLooseChange = (state) => {
-  clearTimer(state, 'looseTimer');
-  if (state.looseChange) clearTimer(state, 'timer');
-};
+  flushPaths() {
+    if (!this.pending.size) return;
+    const list = [...this.pending];
+    this.pending.clear();
+    if (this.onPaths) this.onPaths(list);
+  }
 
-const handleWatchEvent = (state, dir, eventType, filename) => {
-  if (state.closed) return;
-  const name = filename ? `${filename}` : '';
-  const rel = name
-    ? slashRel(path.relative(state.root, path.join(dir, name)))
-    : '';
-  const wanted = state.files.has(rel);
-  if (isReviewEvent(state.root, dir, name)) {
-    state.reviewSeenAt = Date.now();
-    dropLooseChange(state);
-    schedule(state, 'reviewTimer', state.onReview);
-    if (!wanted) return;
+  scheduleChange(loose = false) {
+    const idle = this.timers.change === null;
+    this.looseChange = loose && (idle || this.looseChange);
+    this.schedule('change', () => {
+      if (this.looseChange && this.reviewBurst()) return;
+      this.flushPaths();
+      if (this.onChange) this.onChange();
+    });
   }
-  if (!name) return void scheduleUnnamed(state);
-  if (!wanted && ignoredRel(rel)) return;
-  if (isOwnDirEvent(dir, name)) return;
-  const full = path.join(dir, name);
-  if (unchangedSince(full, state.startedAt)) return;
-  if (eventType === 'rename') state.watchNewDir(full);
-  scheduleChange(state);
-};
 
-const watchOne = (state, target, extra = {}) => {
-  if (state.closed) return;
-  if (state.watched.has(target)) return;
-  try {
-    const onEvent = (eventType, filename) => {
-      handleWatchEvent(state, target, eventType, filename);
-    };
-    const watcher = fs.watch(
-      target,
-      { persistent: false, encoding: 'utf8', ...extra },
-      onEvent,
-    );
-    if (typeof watcher.on === 'function') {
-      watcher.on('error', () => {});
-    }
-    state.watched.add(target);
-    state.watchers.push(watcher);
-  } catch {
-    // missing path or too many watchers
+  scheduleUnnamed() {
+    if (this.reviewBurst()) return;
+    this.pending.add(UNKNOWN_PATH);
+    this.schedule('loose', () => {
+      if (!this.reviewBurst()) this.scheduleChange(true);
+    });
   }
-};
 
-const watchTree = (state, dir) => {
-  watchOne(state, dir, state.dirWatchOpts);
-  if (state.recursive) return;
-  let entries;
-  try {
-    entries = fs.readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return;
+  dropLooseChange() {
+    this.clearTimer('loose');
+    if (this.looseChange) this.clearTimer('change');
   }
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    if (skipDirName(entry.name)) continue;
-    watchTree(state, path.join(dir, entry.name));
+
+  onEvent(dir, eventType, filename) {
+    if (this.closed) return;
+    const name = filename ? `${filename}` : '';
+    const rel = name
+      ? slashRel(path.relative(this.root, path.join(dir, name)))
+      : '';
+    const wanted = this.files.has(rel);
+    if (isRunsRel(rel)) {
+      this.pending.add(rel);
+      if (name && eventType === 'rename') {
+        this.watchNewDir(path.join(dir, name));
+      }
+      return void this.schedule('paths', () => this.flushPaths());
+    }
+    if (isReviewEvent(this.root, dir, name)) {
+      this.reviewSeenAt = Date.now();
+      this.dropLooseChange();
+      this.schedule('review', this.onReview);
+      if (!wanted) return;
+    }
+    if (rel && this.matchReview && this.matchReview(rel)) {
+      this.pending.add(rel);
+      return void this.schedule('paths', () => this.flushPaths());
+    }
+    if (!name) return void this.scheduleUnnamed();
+    if (!wanted && ignoredRel(rel)) return;
+    if (isOwnDirEvent(dir, name)) return;
+    const full = path.join(dir, name);
+    if (unchangedSince(full, this.startedAt)) return;
+    if (eventType === 'rename') this.watchNewDir(full);
+    this.pending.add(rel);
+    this.scheduleChange();
   }
-};
 
-const maybeWatchNewDir = (state, full) => {
-  if (state.recursive) return;
-  let stat;
-  try {
-    stat = fs.statSync(full);
-  } catch {
-    return;
+  watchOne(target, recursive = false) {
+    if (this.closed || this.watched.has(target)) return;
+    try {
+      const options = { persistent: false, encoding: 'utf8', recursive };
+      const watcher = fs.watch(target, options, (eventType, filename) => {
+        this.onEvent(target, eventType, filename);
+      });
+      watcher.on('error', () => {});
+      this.watched.add(target);
+      this.watchers.push(watcher);
+    } catch {
+      // missing path or too many watchers
+    }
   }
-  if (!stat.isDirectory()) return;
-  if (path.basename(full) === '.review') return void watchOne(state, full);
-  if (skipDirName(path.basename(full))) return;
-  watchTree(state, full);
-};
 
-const watchScope = (state, spec) => {
-  const target = path.resolve(state.root, spec);
-  let stat;
-  try {
-    stat = fs.statSync(target);
-  } catch {
-    return void watchOne(state, path.dirname(target));
+  watchTree(dir) {
+    this.watchOne(dir, this.recursive);
+    if (this.recursive) return;
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory() || skipDirName(entry.name)) continue;
+      this.watchTree(path.join(dir, entry.name));
+    }
   }
-  if (stat.isDirectory()) return void watchTree(state, target);
-  watchOne(state, path.dirname(target));
-};
 
-const watchGit = (state) => {
-  const gitDir = path.resolve(state.root, '.git');
-  watchOne(state, gitDir);
-  watchOne(state, path.resolve(gitDir, 'refs'));
-  watchOne(state, path.resolve(gitDir, 'logs'));
-};
+  watchNewDir(full) {
+    if (this.recursive) return;
+    try {
+      if (!fs.statSync(full).isDirectory()) return;
+    } catch {
+      return;
+    }
+    const name = path.basename(full);
+    if (name === '.review') this.watchOne(full);
+    else if (!skipDirName(name)) this.watchTree(full);
+  }
 
-const stopState = (state) => {
-  state.closed = true;
-  clearTimer(state, 'timer');
-  clearTimer(state, 'reviewTimer');
-  clearTimer(state, 'looseTimer');
-  while (state.watchers.length) closeWatcher(state.watchers.pop());
-  state.watched.clear();
-};
+  watchScope(spec) {
+    const target = path.resolve(this.root, spec);
+    try {
+      if (fs.statSync(target).isDirectory()) return void this.watchTree(target);
+    } catch {
+      // watch the parent until the path appears
+    }
+    this.watchOne(path.dirname(target));
+  }
 
-const watchFiles = (state, rels) => {
-  state.files = new Set();
-  for (const rel of rels) {
-    if (!rel) continue;
-    const full = path.resolve(state.root, rel);
-    state.files.add(slashRel(path.relative(state.root, full)));
-    watchOne(state, path.dirname(full));
+  watchFiles(rels) {
+    this.files = new Set();
+    for (const rel of rels) {
+      if (!rel) continue;
+      const full = path.resolve(this.root, rel);
+      this.files.add(slashRel(path.relative(this.root, full)));
+      this.watchOne(path.dirname(full));
+    }
   }
-};
 
-const createDiskWatcher = (options) => {
-  const recursive = options.recursive ?? canWatchRecursive();
-  const state = {
-    root: path.resolve(options.root),
-    debounceMs: options.debounceMs ?? DEBOUNCE_MS,
-    onChange: options.onChange,
-    recursive,
-    dirWatchOpts: recursive ? { recursive: true } : {},
-    watchers: [],
-    watched: new Set(),
-    files: new Set(),
-    onReview: options.onReview,
-    timer: null,
-    reviewTimer: null,
-    looseTimer: null,
-    looseChange: false,
-    reviewSeenAt: 0,
-    startedAt: Date.now(),
-    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),
-  };
-};
+  close() {
+    this.closed = true;
+    for (const key of Object.keys(this.timers)) this.clearTimer(key);
+    this.pending.clear();
+    for (const watcher of this.watchers) {
+      try {
+        watcher.close();
+      } catch {
+        // already closed
+      }
+    }
+    this.watchers = [];
+    this.watched.clear();
+  }
+}
 
 module.exports = {
   DEBOUNCE_MS,
+  UNKNOWN_PATH,
+  MODULES_STAMP,
   canWatchRecursive,
   ignoredRel,
   isOwnDirEvent,
   unchangedSince,
-  createDiskWatcher,
+  DiskWatcher,
 };