reslop 0.2.5 → 0.2.6

package/lib/session.js

@@ -1,19 +1,19 @@
 'use strict';
 
 const render = require('./render/render.js');
+const { renderFrame } = render;
 const keys = require('./keys.js');
+const { decodeChunk } = keys;
 const review = require('./review.js');
+const { AUTOSAVE_MS, hasNotes } = review;
 const files = require('./files.js');
 const { makeTaskItem } = files;
-const { renderFrame } = render;
-const { decodeChunk } = keys;
-const { AUTOSAVE_MS, hasNotes } = review;
 const capabilities = require('./capabilities.js');
+const { sessionCapabilities } = capabilities;
 const actions = require('./session/actions.js');
 const { LIST_PANES } = actions;
-const { sessionCapabilities } = capabilities;
 const terminal = require('./session/terminal.js');
-const { createTerminal, LEAVE_TERM } = terminal;
+const { Terminal, LEAVE_TERM } = terminal;
 const load = require('./session/load.js');
 const { LoadCoordinator } = load;
 const items = require('./session/items.js');
@@ -25,31 +25,27 @@ const { ReviewController } = sessionReview;
 const update = require('./session/update.js');
 const { UpdateCoordinator } = update;
 const progress = require('./session/progress.js');
-const { createProgress } = progress;
+const { Progress } = progress;
 const compose = require('./session/compose.js');
-const { createComposer } = compose;
+const { Composer } = compose;
 const ops = require('./session/ops.js');
 const { OpsRunner } = ops;
-const changeActions = require('./session/change-actions.js');
-const { createChangeActions } = changeActions;
 const commit = require('./session/commit.js');
-const { createCommitController } = commit;
+const { CommitController } = commit;
 const branches = require('./session/branches.js');
-const { createBranchController } = branches;
+const { BranchController } = branches;
 const npm = require('./session/npm.js');
-const { createNpmController } = npm;
+const { NpmController } = npm;
 const accessors = require('./session/accessors.js');
-const { bindAccessors, bindGetters, bindAlias } = accessors;
+const { bindAccessors, bindGetters } = accessors;
 const view = require('./session/view.js');
-const { createView } = view;
 const filesPane = require('./session/files-pane.js');
-const { createFilesPane } = filesPane;
 const lifecycle = require('./session/lifecycle.js');
-const { createLifecycle } = lifecycle;
-const pointer = require('./session/pointer.js');
-const { createPointer } = pointer;
+const { Lifecycle } = lifecycle;
 const dispatch = require('./session/dispatch.js');
-const { createDispatcher, createInput } = dispatch;
+const { dispatchAction, confirmChoice, handleEvent } = dispatch;
+const dashboard = require('./session/dashboard.js');
+const { Dashboard } = dashboard;
 
 const PROGRESS_MS = 160;
 
@@ -77,7 +73,6 @@ const COMPOSER_FIELDS = [
   'composeKind',
   'commitKind',
   'composeTaskId',
-  'composeBaseline',
   'templateIndex',
   'templateFocus',
 ];
@@ -90,11 +85,6 @@ const assignOptions = (session, options) => {
   session.stdout = options.stdout;
   session.proc = options.proc ?? process;
   session.color = options.color ?? true;
-  session.getSize = () => {
-    const width = session.stdout.columns ?? 80;
-    const height = session.stdout.rows ?? 24;
-    return { width, height };
-  };
   session.rev = options.rev ?? null;
   session.revShort = '';
   session.sourceLabel = options.sourceLabel ?? '';
@@ -107,41 +97,31 @@ const assignOptions = (session, options) => {
   session.outdatedMap = options.outdatedMap;
   session.auditMap = options.auditMap;
   session.updateOpts = options.update;
-  session.term = createTerminal({
-    stdin: session.stdin,
-    stdout: session.stdout,
-    proc: session.proc,
-  });
+  session.dashboardHome = options.startPane === 'dashboard';
+};
+
+const assignParts = (session, options) => {
+  const { stdin, stdout, proc } = session;
+  session.term = new Terminal({ stdin, stdout, proc });
   session.loader = new LoadCoordinator();
   session.collection = new ItemCollection();
   session.nav = new Navigation({ startPane: options.startPane ?? 'files' });
   session.review = new ReviewController();
-  session.progress = createProgress(
-    session.term,
-    () => session.tickProgress(),
-    PROGRESS_MS,
-  );
-};
-
-const assignComposer = (session) => {
-  session.composer = createComposer({
-    nav: session.nav,
-    review: session.review,
-    ui: session,
-  });
-};
-
-const assignControllers = (session) => {
+  const tick = () => session.tickProgress();
+  session.progress = new Progress(session.term, tick, PROGRESS_MS);
+  session.updater = new UpdateCoordinator(session);
+  session.composer = new Composer(session);
   session.ops = new OpsRunner(session);
-  session.changeActions = createChangeActions(session);
-  session.commits = createCommitController(session);
-  session.gitBranches = createBranchController(session);
-  session.npm = createNpmController(session);
+  session.commits = new CommitController(session);
+  session.gitBranches = new BranchController(session);
+  session.npm = new NpmController(session);
+  session.dashboard = new Dashboard(session);
+  session.lifecycle = new Lifecycle(session);
 };
 
-const bindSessionAccessors = (session) => {
+const bindFields = (session) => {
   bindAccessors(session, session.nav, NAV_FIELDS);
-  bindAccessors(session, session.composer.state, COMPOSER_FIELDS);
+  bindAccessors(session, session.composer, COMPOSER_FIELDS);
   bindAccessors(session, session.loader, ['pendingExtras']);
   bindGetters(session, session.loader, ['didLoad']);
   bindAccessors(session, session.collection, ['items']);
@@ -150,76 +130,36 @@ const bindSessionAccessors = (session) => {
   bindAccessors(session, session.ops, ['gitBusy', 'busy']);
   bindAccessors(session, session.gitBranches, ['branches', 'dropName']);
   bindGetters(session, session.term, ['lastFrame', 'lastSize']);
-  bindAlias(session, 'notes', () => session.review.store);
-};
-
-const bindViewer = (session) => {
-  session.viewer = createView({
-    nav: session.nav,
-    composer: session.composer,
-    collection: session.collection,
-    review: session.review,
-    gitBranches: session.gitBranches,
-    commits: session.commits,
-    npm: session.npm,
-    updater: session.updater,
-    ui: session,
-  });
-};
-
-const bindLifecycle = (session) => {
-  session.lifecycle = createLifecycle({
-    loader: session.loader,
-    collection: session.collection,
-    review: session.review,
-    nav: session.nav,
-    ops: session.ops,
-    updater: session.updater,
-    loadConfig: {
-      repo: session.repo,
-      cwd: session.cwd,
-      paths: session.paths,
-      audit: session.audit,
-      outdatedMap: session.outdatedMap,
-      auditMap: session.auditMap,
-    },
-    ui: session,
-  });
-};
-
-const bindDispatch = (session) => {
-  session.dispatcher = createDispatcher(session);
-  session.pointer = createPointer(session);
-  session.input = createInput(session);
-};
-
-const composeSession = (session, options) => {
-  assignOptions(session, options);
-  session.updater = new UpdateCoordinator(session);
-  assignComposer(session);
-  assignControllers(session);
-  bindSessionAccessors(session);
-  bindViewer(session);
-  session.filesPane = createFilesPane(session);
-  bindLifecycle(session);
-  bindDispatch(session);
 };
 
 class Session {
   constructor(options) {
-    composeSession(this, options);
+    assignOptions(this, options);
+    assignParts(this, options);
+    bindFields(this);
     this.resetState();
   }
 
+  get notes() {
+    return this.review.store;
+  }
+
+  getSize() {
+    const width = this.stdout.columns ?? 80;
+    const height = this.stdout.rows ?? 24;
+    return { width, height };
+  }
+
   resetState() {
-    if (this.collection) this.collection.reset();
-    if (this.nav) this.nav.reset();
-    if (this.review) this.review.reset();
-    if (this.composer) this.composer.reset();
-    if (this.ops) this.ops.reset();
-    if (this.gitBranches) this.gitBranches.reset();
-    if (this.commits) this.commits.reset();
-    if (this.npm) this.npm.reset();
+    this.collection.reset();
+    this.nav.reset();
+    this.review.reset();
+    this.composer.reset();
+    this.ops.reset();
+    this.gitBranches.reset();
+    this.commits.reset();
+    this.npm.reset();
+    this.dashboard.reset();
     this.top = this.cwd;
     this.branch = '';
     this.status = '';
@@ -233,12 +173,12 @@ class Session {
     this.loadError = null;
     this.uiOpen = false;
     this.finishReadLoop = null;
-    if (this.lifecycle) this.lifecycle.stopWatch();
-    if (this.lifecycle) this.lifecycle.clearNpmExtras();
-    if (this.term) this.term.resetCache();
-    if (this.loader) this.loader.reset();
-    if (this.updater) this.updater.reset();
-    if (this.progress) this.progress.clear();
+    this.lifecycle.stopWatch();
+    this.lifecycle.clearNpmExtras();
+    this.term.resetCache();
+    this.loader.reset();
+    this.updater.reset();
+    this.progress.clear();
   }
 
   ensureRepo() {
@@ -271,8 +211,7 @@ class Session {
   }
 
   paint() {
-    if (!this.uiOpen) return;
-    this.draw();
+    if (this.uiOpen) this.draw();
   }
 
   draw() {
@@ -294,6 +233,7 @@ class Session {
     const composing = this.mode === 'compose';
     this.term.paint(frame, size, composing ? frame.cursor : null);
     this.scheduleAutosave();
+    this.dashboard.afterDraw();
   }
 
   scheduleAutosave() {
@@ -304,19 +244,11 @@ class Session {
   }
 
   view() {
-    return this.viewer.view();
+    return view.view(this);
   }
 
   fileList() {
-    return this.viewer.fileList();
-  }
-
-  counts() {
-    return this.viewer.counts();
-  }
-
-  viewStatus() {
-    return this.viewer.viewStatus();
+    return view.fileList(this);
   }
 
   current() {
@@ -324,31 +256,35 @@ class Session {
   }
 
   fileCursorEntry() {
-    return this.changeActions.fileCursorEntry();
+    return filesPane.fileCursorEntry(this);
   }
 
   clampIndex() {
-    this.filesPane.clampIndex();
+    filesPane.clampIndex(this);
   }
 
   syncReviewPath() {
-    this.filesPane.syncReviewPath();
+    filesPane.syncReviewPath(this);
   }
 
   syncFileCursor() {
-    this.filesPane.syncFileCursor();
+    filesPane.syncFileCursor(this);
   }
 
   showFiles() {
-    this.filesPane.showFiles();
+    filesPane.showFiles(this);
   }
 
   dispatch(action) {
-    this.dispatcher.dispatch(action);
+    dispatchAction(this, action);
+  }
+
+  confirmChoice(key) {
+    confirmChoice(this, key);
   }
 
   handleEvent(event) {
-    this.input.handleEvent(event);
+    handleEvent(this, event);
   }
 
   pushInput(text) {
@@ -376,7 +312,7 @@ class Session {
       this.status = result.error.message;
       return false;
     }
-    if (this.lifecycle) this.lifecycle.noteReviewStamp();
+    this.lifecycle.noteReviewStamp();
     return result.wrote;
   }
 
@@ -388,19 +324,7 @@ class Session {
   }
 
   selectTemplate(index) {
-    this.runComposeCommand(this.composer.selectTemplate(index));
-  }
-
-  idleNoteText() {
-    return this.composer.idleNoteText();
-  }
-
-  shownTemplates() {
-    return this.composer.shownTemplates();
-  }
-
-  startDraftCompose() {
-    this.composer.startDraftCompose();
+    this.runComposeCommand(this.composer.templates.selectTemplate(index));
   }
 
   autosave() {
@@ -487,6 +411,7 @@ class Session {
         if (settled) return;
         settled = true;
         this.lifecycle.stopWatch();
+        this.dashboard.stop();
         this.term.stopListening();
         this.progress.clear();
         this.term.clearTimers();
@@ -503,16 +428,11 @@ class Session {
         if (this.done) return void finish();
         this.draw();
       };
-      this.term.startListening({
-        onData,
-        onResize: () => this.draw(),
-      });
+      this.term.startListening({ onData, onResize: () => this.draw() });
       this.lifecycle.startWatch();
+      if (this.dashboardHome) this.dashboard.start();
     });
   }
 }
 
-module.exports = {
-  LEAVE_TERM,
-  Session,
-};
+module.exports = { LEAVE_TERM, Session };

package/lib/update.js

@@ -21,19 +21,10 @@ const INSTALL_MS = 120000;
 const REGISTRY = 'https://registry.npmjs.org';
 
 const RELEASE = /^\d+\.\d+\.\d+$/;
-const emptyCache = () => ({
-  checkedAt: 0,
-  compatible: '',
-  major: '',
-  skipped: '',
-});
+const NO_TARGETS = { compatible: '', major: '' };
 
-const toInt = (text) => parseInt(text, 10);
-
-const isNpmInstall = (pkgDir) => {
-  const parent = path.basename(path.dirname(pkgDir));
-  return parent === 'node_modules';
-};
+const isNpmInstall = (pkgDir) =>
+  path.basename(path.dirname(pkgDir)) === 'node_modules';
 
 const cacheFile = (env = process.env) => {
   if (env.XDG_CACHE_HOME) {
@@ -49,29 +40,26 @@ const cacheFile = (env = process.env) => {
 
 const readCache = (file) => {
   try {
-    const text = fs.readFileSync(file, 'utf8');
-    const data = jsonParse(text);
-    if (!isHashObject(data)) {
-      return emptyCache();
+    const data = jsonParse(fs.readFileSync(file, 'utf8'));
+    if (isHashObject(data)) {
+      return {
+        checkedAt: parseInt(data.checkedAt, 10) || 0,
+        compatible: asText(data.compatible),
+        major: asText(data.major) || asText(data.latest),
+        skipped: asText(data.skipped) || asText(data.handled),
+      };
     }
-    const checkedAt = toInt(data.checkedAt) || 0;
-    const compatible = asText(data.compatible);
-    const major = asText(data.major) || asText(data.latest);
-    const skipped = asText(data.skipped) || asText(data.handled);
-    return { checkedAt, compatible, major, skipped };
   } catch {
-    return emptyCache();
+    // missing or unreadable cache
   }
+  return { checkedAt: 0, compatible: '', major: '', skipped: '' };
 };
 
 const writeCache = (file, data) => {
+  const { checkedAt, compatible, major, skipped } = data;
+  const body = JSON.stringify({ checkedAt, compatible, major, skipped });
   try {
     fs.mkdirSync(path.dirname(file), { recursive: true });
-    const checkedAt = data.checkedAt ?? 0;
-    const compatible = data.compatible ?? '';
-    const major = data.major ?? '';
-    const skipped = data.skipped ?? '';
-    const body = JSON.stringify({ checkedAt, compatible, major, skipped });
     fs.writeFileSync(file, `${body}\n`);
   } catch {
     // ignore cache write errors
@@ -79,76 +67,43 @@ const writeCache = (file, data) => {
 };
 
 const isFresh = (cache, now, interval = CHECK_INTERVAL_MS) => {
-  if (!cache || !cache.checkedAt) return false;
-  if (now < cache.checkedAt) return false;
+  if (!cache.checkedAt || now < cache.checkedAt) return false;
   return now - cache.checkedAt < interval;
 };
 
 const listVersions = (data) => {
   if (!data || typeof data !== 'object') return [];
   const names = [];
-  const map = data.versions;
-  if (isHashObject(map)) {
-    for (const name of Object.keys(map)) names.push(name);
-  }
+  if (isHashObject(data.versions)) names.push(...Object.keys(data.versions));
   const tags = data['dist-tags'];
   if (tags && typeof tags.latest === 'string') names.push(tags.latest);
   if (typeof data.version === 'string') names.push(data.version);
-  const listed = [];
-  for (const name of names) {
-    if (!RELEASE.test(name)) continue;
-    if (listed.includes(name)) continue;
-    listed.push(name);
-  }
-  return listed;
+  return [...new Set(names)].filter((name) => RELEASE.test(name));
 };
 
-const pickNewerName = (best, name, ver) => {
+const newer = (best, name) => {
   if (!best) return name;
-  const prev = parseVersion(best);
-  if (!prev || cmpVersion(ver, prev) > 0) return name;
-  return best;
+  return cmpVersion(parseVersion(name), parseVersion(best)) > 0 ? name : best;
 };
 
 const pickTargets = (current, names) => {
   const from = parseVersion(current);
-  if (!from) return { compatible: '', major: '' };
+  if (!from) return NO_TARGETS;
   let compatible = '';
   let major = '';
   for (const name of names) {
     const ver = parseVersion(name);
-    if (!ver) continue;
     if (cmpVersion(ver, from) <= 0) continue;
-    if (ver.major === from.major) {
-      compatible = pickNewerName(compatible, name, ver);
-      continue;
-    }
-    if (ver.major > from.major) major = pickNewerName(major, name, ver);
+    if (ver.major === from.major) compatible = newer(compatible, name);
+    else if (ver.major > from.major) major = newer(major, name);
   }
   return { compatible, major };
 };
 
-const classifyLatest = (current, latest) => {
-  const from = parseVersion(current);
-  const to = parseVersion(latest);
-  if (!from || !to || cmpVersion(to, from) <= 0) {
-    return { compatible: '', major: '' };
-  }
-  if (to.major > from.major) return { compatible: '', major: latest };
-  return { compatible: latest, major: '' };
-};
-
-const planUpdate = (current, extra = {}) => {
+const planUpdate = (current, targets) => {
   const from = parseVersion(current);
   if (!from) return { action: 'none' };
-  let compatible = extra.compatible ?? '';
-  let major = extra.major ?? '';
-  const skipped = extra.skipped ?? extra.handled ?? '';
-  if (!compatible && !major && extra.latest) {
-    const classified = classifyLatest(current, extra.latest);
-    compatible = classified.compatible;
-    major = classified.major;
-  }
+  const { compatible, major, skipped } = targets;
   const compatVer = parseVersion(compatible);
   if (compatVer && compatVer.major === from.major) {
     if (cmpVersion(compatVer, from) > 0) {
@@ -162,53 +117,40 @@ const planUpdate = (current, extra = {}) => {
   return { action: 'confirm', current, latest: major };
 };
 
-const isEnabled = (options = {}) => {
-  if (options.enabled === false) return false;
-  if (options.enabled === true) return true;
-  const pkgDir = options.pkgDir ?? PKG_DIR;
-  return isNpmInstall(pkgDir);
+const isEnabled = (options) => {
+  if (typeof options.enabled === 'boolean') return options.enabled;
+  return isNpmInstall(options.pkgDir ?? PKG_DIR);
 };
 
-const fetchTargets = async (current, options = {}) => {
-  const empty = { compatible: '', major: '' };
+const fetchTargets = async (current, options) => {
   const fetchImpl = options.fetch ?? globalThis.fetch;
-  if (typeof fetchImpl !== 'function') return empty;
-  const encoded = encodeURIComponent(PKG_NAME);
-  const url = `${REGISTRY}/${encoded}`;
+  if (typeof fetchImpl !== 'function') return NO_TARGETS;
+  const url = `${REGISTRY}/${encodeURIComponent(PKG_NAME)}`;
   const headers = { accept: 'application/json' };
   const signal = options.signal ?? AbortSignal.timeout(FETCH_MS);
   const response = await fetchImpl(url, { headers, signal });
-  if (!response || !response.ok) return empty;
+  if (!response || !response.ok) return NO_TARGETS;
   const data = await response.json();
   return pickTargets(current, listVersions(data));
 };
 
-const npmInstall = async (spec, extra = {}) => {
-  const timeout = extra.timeout ?? INSTALL_MS;
-  const result = await runProc(
-    npmBin(),
-    ['install', '-g', spec],
-    npmOpts({ timeout }),
-  );
-  if (result.error) throw result.error;
-  if (result.status !== 0) {
-    throw new Error(oneLine(result.stderr, 'npm install failed'));
-  }
-};
-
 const installUpdate = async (version, options = {}) => {
   if (typeof options.install === 'function') {
     await options.install(version);
     return;
   }
-  const spec = `${PKG_NAME}@${version}`;
-  await npmInstall(spec, options);
+  const timeout = options.timeout ?? INSTALL_MS;
+  const args = ['install', '-g', `${PKG_NAME}@${version}`];
+  const result = await runProc(npmBin(), args, npmOpts({ timeout }));
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    throw new Error(oneLine(result.stderr, 'npm install failed'));
+  }
 };
 
 const markSkipped = (version, options = {}) => {
   const file = options.cacheFile ?? cacheFile(options.env);
-  const cache = readCache(file);
-  writeCache(file, { ...cache, skipped: version });
+  writeCache(file, { ...readCache(file), skipped: version });
 };
 
 const checkUpdate = async (options = {}) => {
@@ -216,37 +158,28 @@ const checkUpdate = async (options = {}) => {
   const now = Date.now();
   const current = options.current ?? PKG_VERSION;
   const file = options.cacheFile ?? cacheFile(options.env);
-  const interval = options.interval ?? CHECK_INTERVAL_MS;
   const cache = readCache(file);
-  if (isFresh(cache, now, interval)) {
+  if (isFresh(cache, now, options.interval)) {
     const plan = planUpdate(current, cache);
-    if (plan.action === 'install') return { action: 'none' };
-    return plan;
+    return plan.action === 'install' ? { action: 'none' } : plan;
   }
-  let targets = { compatible: '', major: '' };
+  let targets = NO_TARGETS;
   try {
     targets = await fetchTargets(current, options);
   } catch {
     // ignore registry errors
   }
-  const next = {
-    ...cache,
-    checkedAt: now,
-    compatible: targets.compatible,
-    major: targets.major,
-  };
   if (!targets.compatible && !targets.major) {
     writeCache(file, { ...cache, checkedAt: now });
     return { action: 'none' };
   }
+  const next = { ...cache, checkedAt: now, ...targets };
   writeCache(file, next);
   return planUpdate(current, next);
 };
 
 module.exports = {
   CHECK_INTERVAL_MS,
-  parseVersion,
-  cmpVersion,
   isNpmInstall,
   cacheFile,
   readCache,