reslop 0.1.9 → 0.2.0

package/lib/select.js

@@ -145,8 +145,6 @@ const parseCells = (line) => {
 
 const rgbKey = (rgb) => (rgb ? `${rgb[0]},${rgb[1]},${rgb[2]}` : '');
 
-const styleKey = (fg, bg) => `${rgbKey(fg)}|${rgbKey(bg)}`;
-
 const styleSeq = (fg, bg) => {
   if (fg && bg) return RESET + seq(fg, bg);
   if (fg) return RESET + ansi.fg(fg);
@@ -169,7 +167,7 @@ const overlayRange = (line, fromCol, toCol) => {
       fg = cell.bg ?? THEME.ctxBg;
       bg = cell.fg ?? THEME.ctxFg;
     }
-    const key = styleKey(fg, bg);
+    const key = `${rgbKey(fg)}|${rgbKey(bg)}`;
     if (key !== last) {
       out += styleSeq(fg, bg);
       last = key;
@@ -181,14 +179,11 @@ const overlayRange = (line, fromCol, toCol) => {
 
 const overlayRows = (rows, sel) => {
   if (!isRange(sel)) return rows;
-  const next = [];
-  for (let i = 0; i < rows.length; i++) {
+  const { length } = rows;
+  const next = new Array(length);
+  for (let i = 0; i < length; i++) {
     const range = lineRange(i, sel);
-    if (!range) {
-      next.push(rows[i]);
-      continue;
-    }
-    next.push(overlayRange(rows[i], range.from, range.to));
+    next[i] = range ? overlayRange(rows[i], range.from, range.to) : rows[i];
   }
   return next;
 };

package/lib/session/accessors.js

@@ -22,4 +22,12 @@ const bindGetters = (target, owner, names) => {
   }
 };
 
-module.exports = { bindAccessors, bindGetters, bindAlias };
+const stateView = (state, methods, writable = [], readonly = []) => {
+  const descriptors = Object.getOwnPropertyDescriptors(methods);
+  const view = Object.defineProperties({}, descriptors);
+  bindAccessors(view, state, writable);
+  bindGetters(view, state, readonly);
+  return view;
+};
+
+module.exports = { bindAccessors, bindGetters, bindAlias, stateView };

package/lib/session/actions.js

@@ -12,6 +12,8 @@ const ACTIONS = {
   todo: ['t'],
   code: ['e'],
   branch: ['b'],
+  file: ['f'],
+  diff: ['d'],
   quit: ['q', 'ctrl-c'],
 };
 const ACTION_IDS = Object.keys(ACTIONS);
@@ -28,6 +30,8 @@ const COMMIT_ACTIONS = {
   amend: ['a'],
   fixup: ['f'],
   drop: ['d'],
+  pull: ['p'],
+  push: ['s'],
 };
 
 const ACTION_HOT = {
@@ -45,9 +49,17 @@ const ACTION_LABEL = {
   next: '→',
 };
 
-const DIFF_DISABLED = ['commit', 'branch', 'pull', 'push'];
+const DIFF_DISABLED = ['commit', 'branch', 'pull', 'push', 'file', 'diff'];
+const UNIT_DISABLED = [...DIFF_DISABLED, 'layout'];
 const FILES_DISABLED = ['layout', 'feedback', 'code'];
-const FILES_HIDDEN = [...FILES_DISABLED, 'prev', 'next', 'commit'];
+const FILES_HIDDEN = [
+  ...FILES_DISABLED,
+  'prev',
+  'next',
+  'commit',
+  'file',
+  'diff',
+];
 const FILES_GIT_DISABLED = ['add', 'unstage', 'revert'];
 const FILES_TODO_DISABLED = [...FILES_GIT_DISABLED, ...FILES_DISABLED];
 const TODO_DISABLED = [
@@ -60,6 +72,8 @@ const TODO_DISABLED = [
   'todo',
   'code',
   'branch',
+  'file',
+  'diff',
   'pull',
   'push',
 ];
@@ -73,6 +87,8 @@ const BRANCHES_DISABLED = [
   'todo',
   'code',
   'branch',
+  'file',
+  'diff',
   'prev',
   'next',
 ];
@@ -85,10 +101,10 @@ const COMMITS_DISABLED = [
   'todo',
   'code',
   'branch',
+  'file',
+  'diff',
   'prev',
   'next',
-  'pull',
-  'push',
 ];
 
 const isTodosTarget = (item) =>
@@ -122,6 +138,7 @@ const commitGitDisabled = (item) => {
 const disabledActions = (pane, item) => {
   const onTodos = isTodosTarget(item);
   if (pane === 'files') return onTodos ? FILES_TODO_DISABLED : FILES_DISABLED;
+  if (pane === 'unit') return [...UNIT_DISABLED, ...diffGitDisabled(item)];
   if (pane === 'branches') {
     return [...BRANCHES_DISABLED, ...branchGitDisabled(item)];
   }
@@ -151,11 +168,9 @@ const SCROLL = {
 };
 
 const KEY_TO_ACTION = {};
-const PANE_ONLY = ['branch'];
+const PANE_ONLY = ['branch', 'file', 'diff'];
 const FILES_KEYS = {};
-for (const id of PANE_ONLY) {
-  for (const key of ACTIONS[id]) FILES_KEYS[key] = id;
-}
+for (const key of ACTIONS.branch) FILES_KEYS[key] = 'branch';
 for (const id of BRANCH_REMOTE) {
   for (const key of BRANCH_ACTIONS[id]) FILES_KEYS[key] = id;
 }
@@ -180,12 +195,16 @@ for (const id of ACTION_IDS) {
 
 for (const key of Object.keys(SCROLL)) KEY_TO_ACTION[key] = SCROLL[key];
 
-const actionFromKey = (key, pane) => {
+const actionFromKey = (key, pane, fileScope) => {
   const listPane =
     pane === 'files' || pane === 'branches' || pane === 'commits';
   if (listPane && (key === 'left' || key === 'right')) return null;
   const paneKeys = PANE_KEYS[pane];
   if (paneKeys && paneKeys[key]) return paneKeys[key];
+  if (pane === 'files') {
+    if (key === 'f' && fileScope !== 'file') return 'file';
+    if (key === 'd' && fileScope === 'file') return 'diff';
+  }
   return KEY_TO_ACTION[key] ?? null;
 };
 
@@ -194,12 +213,10 @@ const actionKeys = (id) =>
 
 const actionHot = (id) => ACTION_HOT[id] ?? actionKeys(id)[0];
 
-const actionLabel = (id) => ACTION_LABEL[id] ?? ACTION_HOT[id] ?? id;
-
 const actionLetter = actionHot;
 
 const buttonWord = (id) => {
-  const word = actionLabel(id);
+  const word = ACTION_LABEL[id] ?? ACTION_HOT[id] ?? id;
   const mark = actionLetter(id);
   if (word.includes(mark)) return word;
   return `${mark}${word}`;
@@ -257,13 +274,11 @@ const CONFIRM = {
 
 const CONFIRM_MODE = Object.keys(CONFIRM);
 
-const normalizeConfirmKey = (key) =>
-  key.length === 1 ? key.toLowerCase() : key;
-
 const confirmKey = (mode, key) => {
   const spec = CONFIRM[mode];
   if (!spec) return null;
-  return spec.keys[normalizeConfirmKey(key)] ?? null;
+  const norm = key.length === 1 ? key.toLowerCase() : key;
+  return spec.keys[norm] ?? null;
 };
 
 const applyConfirm = (mode, key, handlers) => {
@@ -289,6 +304,7 @@ module.exports = {
   ACTION_HOT,
   ACTION_LABEL,
   DIFF_DISABLED,
+  UNIT_DISABLED,
   FILES_DISABLED,
   FILES_HIDDEN,
   FILES_GIT_DISABLED,

package/lib/session/branches.js

@@ -1,261 +1,257 @@
 'use strict';
 
+const { stateView } = require('./accessors.js');
+
 const { pickRepoWrite } = require('./ops.js');
 
 const selectedBranch = (api) => {
-  const cursor = api.options.nav.branchCursor;
+  const cursor = api.ui.nav.branchCursor;
   return api.state.branches[cursor];
 };
 
 const refreshBranchList = (api) => {
-  const repo = api.options.repo();
+  const repo = api.ui.repo;
   if (!repo.listBranches) return;
   try {
-    api.state.branches = repo.listBranches(api.options.top());
+    api.state.branches = repo.listBranches(api.ui.top);
   } catch (error) {
-    api.options.setStatus(error.message);
+    api.ui.status = error.message;
     return;
   }
   const last = api.state.branches.length - 1;
-  const nav = api.options.nav;
+  const nav = api.ui.nav;
   if (nav.branchCursor > last) nav.branchCursor = Math.max(0, last);
 };
 
 const refreshAfterWrite = (api, extra = {}) => {
   refreshBranchList(api);
-  api.options.refreshFromRepo({ keepEmpty: true, ...extra });
+  api.ui.commits.refresh();
+  api.ui.refreshFromRepo({ keepEmpty: true, ...extra });
 };
 
 const onBranch = (api) => {
-  if (api.options.getMode() === 'compose') return;
-  if (!api.options.canCommit()) return;
-  const repo = api.options.repo();
-  const caps = api.options.capabilities();
+  if (api.ui.mode === 'compose') return;
+  if (!api.ui.commits.canCommit()) return;
+  const repo = api.ui.repo;
+  const caps = api.ui.capabilities;
   if (!caps.branches || !repo.listBranches) {
-    api.options.setStatus('read only');
+    api.ui.status = 'read only';
     return;
   }
   try {
-    api.state.branches = repo.listBranches(api.options.top());
+    api.state.branches = repo.listBranches(api.ui.top);
   } catch (error) {
-    api.options.setStatus(error.message);
+    api.ui.status = error.message;
     return;
   }
   const current = api.state.branches.findIndex((entry) => entry.current);
-  api.options.nav.branchCursor = current < 0 ? 0 : current;
-  api.options.nav.pane = 'branches';
-  api.options.setStatus('');
-  api.options.nav.clearSelection();
+  api.ui.nav.branchCursor = current < 0 ? 0 : current;
+  api.ui.nav.pane = 'branches';
+  api.ui.status = '';
+  api.ui.nav.clearSelection();
 };
 
 const onBranchMove = (api, delta) => {
   const branches = api.state.branches;
   if (!branches.length) {
-    api.options.setStatus('nothing to review');
+    api.ui.status = 'nothing to review';
     return;
   }
   const next = Math.min(
     branches.length - 1,
-    Math.max(0, api.options.nav.branchCursor + delta),
+    Math.max(0, api.ui.nav.branchCursor + delta),
   );
-  if (next === api.options.nav.branchCursor) return;
-  api.options.nav.branchCursor = next;
-  api.options.setStatus('');
+  if (next === api.ui.nav.branchCursor) return;
+  api.ui.nav.branchCursor = next;
+  api.ui.status = '';
 };
 
 const checkoutAsync = (api, name, done, write) => {
-  api.options.showFiles();
+  api.ui.showFiles();
   const run = (top) => write(top, name);
   const after = () =>
-    api.options.refreshFromRepo({ keepEmpty: true, doneStatus: done });
-  return void api.options.runner.runBusy('checking out', done, run, after);
+    api.ui.refreshFromRepo({ keepEmpty: true, doneStatus: done });
+  return void api.ui.ops.runBusy('checking out', done, run, after);
 };
 
 const onCheckoutBranch = (api) => {
-  if (!api.options.canCommit()) return;
+  if (!api.ui.commits.canCommit()) return;
   const entry = selectedBranch(api);
   if (!entry) return;
-  if (entry.current) {
-    api.options.showFiles();
-    return;
-  }
+  if (entry.current) return void api.ui.showFiles();
   const name = entry.name;
   const done = `checked out ${name}`;
-  const uiOpen = api.options.uiOpen();
-  const picked = pickRepoWrite(api.options.repo(), 'checkout', uiOpen);
+  const uiOpen = api.ui.uiOpen;
+  const picked = pickRepoWrite(api.ui.repo, 'checkout', uiOpen);
   if (picked.async) {
-    checkoutAsync(api, name, done, picked.write);
-    return;
+    return void checkoutAsync(api, name, done, picked.write);
   }
-  const ok = api.options.runner.runRepo(done, (top) => {
-    api.options.repo().checkout(top, name);
+  const ok = api.ui.ops.runRepo(done, (top) => {
+    api.ui.repo.checkout(top, name);
   });
   if (!ok) return;
-  api.options.showFiles();
-  api.options.refreshFromRepo({ keepEmpty: true });
-  if (!api.options.getStatus()) api.options.setStatus(done);
+  api.ui.showFiles();
+  api.ui.refreshFromRepo({ keepEmpty: true });
+  if (!api.ui.status) api.ui.status = done;
 };
 
 const rebaseAsync = (api, onto, done, write) => {
   const run = (top) => write(top, onto);
   const after = () => refreshAfterWrite(api, { doneStatus: done });
-  return void api.options.runner.runBusy('rebasing', done, run, after);
+  return void api.ui.ops.runBusy('rebasing', done, run, after);
 };
 
 const onRebaseBranch = (api) => {
-  if (api.options.nav.pane !== 'branches') return;
-  if (!api.options.canCommit()) return;
+  if (api.ui.nav.pane !== 'branches') return;
+  if (!api.ui.commits.canCommit()) return;
   const entry = selectedBranch(api);
   if (!entry || entry.current) return;
   const onto = entry.name;
   const done = `rebased onto ${onto}`;
-  const uiOpen = api.options.uiOpen();
-  const picked = pickRepoWrite(api.options.repo(), 'rebase', uiOpen);
+  const uiOpen = api.ui.uiOpen;
+  const picked = pickRepoWrite(api.ui.repo, 'rebase', uiOpen);
   if (picked.async) {
-    rebaseAsync(api, onto, done, picked.write);
-    return;
+    return void rebaseAsync(api, onto, done, picked.write);
   }
-  const ok = api.options.runner.runRepo(done, (top) => {
-    api.options.repo().rebase(top, onto);
+  const ok = api.ui.ops.runRepo(done, (top) => {
+    api.ui.repo.rebase(top, onto);
   });
   if (!ok) return;
   refreshAfterWrite(api);
-  if (!api.options.getStatus()) api.options.setStatus(done);
+  if (!api.ui.status) api.ui.status = done;
 };
 
 const onDropBranch = (api) => {
-  if (api.options.nav.pane !== 'branches') return;
-  if (!api.options.canCommit()) return;
+  if (api.ui.nav.pane !== 'branches') return;
+  if (!api.ui.commits.canCommit()) return;
   const entry = selectedBranch(api);
   if (!entry || entry.current) return;
   api.state.dropName = entry.name;
-  api.options.setMode('confirmDrop');
-  api.options.setStatus('');
+  api.ui.mode = 'confirmDrop';
+  api.ui.status = '';
 };
 
 const cancelDropBranch = (api) => {
-  api.options.setMode('review');
+  api.ui.mode = 'review';
   api.state.dropName = '';
-  api.options.setStatus('');
+  api.ui.status = '';
 };
 
 const dropAsync = (api, name, done, write) => {
   const run = (top) => write(top, name);
   const after = () => refreshAfterWrite(api, { doneStatus: done });
-  return void api.options.runner.runBusy('dropping', done, run, after);
+  return void api.ui.ops.runBusy('dropping', done, run, after);
 };
 
 const confirmDropBranch = (api) => {
   const name = api.state.dropName;
-  api.options.setMode('review');
+  api.ui.mode = 'review';
   api.state.dropName = '';
   if (!name) return;
   const done = `dropped ${name}`;
-  const uiOpen = api.options.uiOpen();
-  const picked = pickRepoWrite(api.options.repo(), 'drop', uiOpen);
+  const uiOpen = api.ui.uiOpen;
+  const picked = pickRepoWrite(api.ui.repo, 'drop', uiOpen);
   if (picked.async) {
-    dropAsync(api, name, done, picked.write);
-    return;
+    return void dropAsync(api, name, done, picked.write);
   }
-  const ok = api.options.runner.runRepo(done, (top) => {
-    api.options.repo().drop(top, name);
+  const ok = api.ui.ops.runRepo(done, (top) => {
+    api.ui.repo.drop(top, name);
   });
   if (!ok) return;
   refreshAfterWrite(api);
-  if (!api.options.getStatus()) api.options.setStatus(done);
+  if (!api.ui.status) api.ui.status = done;
 };
 
 const onNewBranch = (api) => {
-  if (api.options.nav.pane !== 'branches') return;
-  if (!api.options.canCommit()) return;
-  api.options.composer.openCompose('branch', '');
+  if (api.ui.nav.pane !== 'branches') return;
+  if (!api.ui.commits.canCommit()) return;
+  api.ui.composer.openCompose('branch', '');
 };
 
 const createAsync = (api, name, done, write) => {
-  api.options.composer.closeCompose();
-  api.options.showFiles();
+  api.ui.composer.closeCompose();
+  api.ui.showFiles();
   const run = (top) => write(top, name);
   const after = () => refreshAfterWrite(api, { doneStatus: done });
-  return void api.options.runner.runBusy('creating branch', done, run, after);
+  return void api.ui.ops.runBusy('creating branch', done, run, after);
 };
 
 const finishCreateBranch = (api) => {
-  const editor = api.options.composer.state.editor;
+  const editor = api.ui.composer.state.editor;
   const name = editor ? editor.text.trim() : '';
   if (!name) {
-    api.options.setStatus('empty branch name');
+    api.ui.status = 'empty branch name';
     return;
   }
   const done = `created ${name}`;
-  const uiOpen = api.options.uiOpen();
-  const picked = pickRepoWrite(api.options.repo(), 'createBranch', uiOpen);
+  const uiOpen = api.ui.uiOpen;
+  const picked = pickRepoWrite(api.ui.repo, 'createBranch', uiOpen);
   if (picked.async) {
-    createAsync(api, name, done, picked.write);
-    return;
+    return void createAsync(api, name, done, picked.write);
   }
-  const ok = api.options.runner.runRepo(done, (top) => {
-    api.options.repo().createBranch(top, name);
+  const ok = api.ui.ops.runRepo(done, (top) => {
+    api.ui.repo.createBranch(top, name);
   });
   if (!ok) return;
-  api.options.composer.closeCompose();
-  api.options.showFiles();
+  api.ui.composer.closeCompose();
+  api.ui.showFiles();
   refreshAfterWrite(api);
-  if (!api.options.getStatus()) api.options.setStatus(done);
+  if (!api.ui.status) api.ui.status = done;
 };
 
 const onPull = (api) => {
-  if (!api.options.canCommit()) return;
-  const repo = api.options.repo();
-  const picked = pickRepoWrite(repo, 'pull', api.options.uiOpen());
+  if (!api.ui.commits.canCommit()) return;
+  const repo = api.ui.repo;
+  const picked = pickRepoWrite(repo, 'pull', api.ui.uiOpen);
   if (picked.async) {
     const after = () => refreshAfterWrite(api);
     const write = (top) => picked.write(top);
-    return void api.options.runner.runBusy('pulling', 'pulled', write, after);
+    return void api.ui.ops.runBusy('pulling', 'pulled', write, after);
   }
-  const ok = api.options.runner.runRepo('pulled', (top) => {
+  const ok = api.ui.ops.runRepo('pulled', (top) => {
     repo.pull(top);
   });
   if (!ok) return;
   refreshAfterWrite(api);
-  if (!api.options.getStatus()) api.options.setStatus('pulled');
+  if (!api.ui.status) api.ui.status = 'pulled';
 };
 
 const startPush = (api, force) => {
-  if (!api.options.canCommit()) return;
+  if (!api.ui.commits.canCommit()) return;
   const done = force ? 'force pushed' : 'pushed';
   const kind = force ? 'force pushing' : 'pushing';
-  const repo = api.options.repo();
-  const picked = pickRepoWrite(repo, 'push', api.options.uiOpen());
+  const repo = api.ui.repo;
+  const picked = pickRepoWrite(repo, 'push', api.ui.uiOpen);
   if (picked.async) {
     const write = (top) => picked.write(top, force);
     const after = () => refreshAfterWrite(api);
-    return void api.options.runner.runBusy(kind, done, write, after);
+    return void api.ui.ops.runBusy(kind, done, write, after);
   }
   try {
-    repo.push(api.options.top(), force);
+    repo.push(api.ui.top, force);
   } catch (error) {
     if (error.rejected && !force) {
-      api.options.setMode('confirmPush');
-      api.options.setStatus('');
+      api.ui.mode = 'confirmPush';
+      api.ui.status = '';
       return;
     }
-    api.options.setStatus(error.message);
+    api.ui.status = error.message;
     return;
   }
   refreshAfterWrite(api);
-  api.options.setStatus(done);
+  api.ui.status = done;
 };
 
 const onPush = (api) => startPush(api, false);
 
 const onForcePush = (api) => {
-  api.options.setMode('review');
+  api.ui.mode = 'review';
   startPush(api, true);
 };
 
 const cancelPush = (api) => {
-  api.options.setMode('review');
-  api.options.setStatus('');
+  api.ui.mode = 'review';
+  api.ui.status = '';
 };
 
 const reset = (state) => {
@@ -263,40 +259,32 @@ const reset = (state) => {
   state.dropName = '';
 };
 
-const createBranchController = (options) => {
+const createBranchController = (ui) => {
   const state = {
     branches: [],
     dropName: '',
   };
-  const api = { options, state };
-  return {
-    get branches() {
-      return state.branches;
-    },
-    set branches(value) {
-      state.branches = value;
-    },
-    get dropName() {
-      return state.dropName;
+  const api = { ui, state };
+  return stateView(
+    state,
+    {
+      reset: () => reset(state),
+      onBranch: () => onBranch(api),
+      onBranchMove: (delta) => onBranchMove(api, delta),
+      onCheckoutBranch: () => onCheckoutBranch(api),
+      onRebaseBranch: () => onRebaseBranch(api),
+      onDropBranch: () => onDropBranch(api),
+      cancelDropBranch: () => cancelDropBranch(api),
+      confirmDropBranch: () => confirmDropBranch(api),
+      onNewBranch: () => onNewBranch(api),
+      finishCreateBranch: () => finishCreateBranch(api),
+      onPull: () => onPull(api),
+      onPush: () => onPush(api),
+      onForcePush: () => onForcePush(api),
+      cancelPush: () => cancelPush(api),
     },
-    set dropName(value) {
-      state.dropName = value;
-    },
-    reset: () => reset(state),
-    onBranch: () => onBranch(api),
-    onBranchMove: (delta) => onBranchMove(api, delta),
-    onCheckoutBranch: () => onCheckoutBranch(api),
-    onRebaseBranch: () => onRebaseBranch(api),
-    onDropBranch: () => onDropBranch(api),
-    cancelDropBranch: () => cancelDropBranch(api),
-    confirmDropBranch: () => confirmDropBranch(api),
-    onNewBranch: () => onNewBranch(api),
-    finishCreateBranch: () => finishCreateBranch(api),
-    onPull: () => onPull(api),
-    onPush: () => onPush(api),
-    onForcePush: () => onForcePush(api),
-    cancelPush: () => cancelPush(api),
-  };
+    ['branches', 'dropName'],
+  );
 };
 
 module.exports = { createBranchController };