reslop 0.2.4 → 0.2.5

package/lib/session/load.js

@@ -1,73 +1,66 @@
 'use strict';
 
-const accessors = require('./accessors.js');
-const { stateView } = accessors;
-
 const utilities = require('../utilities.js');
 const { isAbort: isAbortError } = utilities;
 
-const createLoadCoordinator = () => {
-  const state = {
-    gen: 0,
-    abort: null,
-    promise: null,
-    pendingExtras: false,
-    didLoad: false,
-  };
+class LoadCoordinator {
+  constructor() {
+    this.gen = 0;
+    this.abortController = null;
+    this.promise = null;
+    this.pendingExtras = false;
+    this.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,107 +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,
-  lastClick: 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 };