Redux refactor (#1571)

* refactor categorical controls state

* lint

* fix race condition in tests

* fix typo

* add missing update on subset

* remove obsolete code

* update jest and puppeteer major version; update all minors

* update when label changes

* remove lint from tests; increase timeouts in e2e tests

* initial refactoring to new async annomatrix

* refine error handling

* fix bad merge

* add continuous legend

* lint

* fix memoization in color table creators

* partial implementation of user defined annotations

* add new annotations action creator file

* first pass at user annotations

* additional user annotation bug fixes

* user annotation auto-save

* unit test cleanup

* lint

* refactor into multiple files

* cleanup

* add column GC

* fix several bugs in user annotations

* remove debug code

* no anonymous functions

* undo redo cleanup

* file cleanup

* scatterplot

* performance

* cleanup

* remove old code

* render in parallel with load

* fix race condition

* simply graph rendering

* render throttle DRY

* fix category label order

* fix typo in e2e test setup

* re-fix the e2e test setup

* be more tolerant of races

* anno matrix unit tests

* temp disable reembedding

* pilot port continuous histo to react-async

* name change

* lint

* fix repaint bug

* typo fix

* update snap to match new ids

* world/universe name cleanup

* move annoMatrix to src dir

* use private underscore naming convention

* fix corner case in all selected

* name cleanup

* add layout control

* init edge case

* lint

* port scatterplot

* fix label indexing bug and improve tests

* port category to react-async

* fix user annotation labelling while subset

* select all of prev layout on layout switch

* fix race with crossfilter update

* prettier lint

* fix misleading comment

* fix url composition in loader

* first pass at crossfilter tests

* lint

* lint

* fix typo

* improved error handling for network errors

* fix memoization bug

* add memo

* refactor for performnce

* add missing single-value handling in select exact parser

* small bugs discovered by tests

* lint

* additional crossfilter unit tests

* remove extraneous comment

* add support for automatic category determination

* lint

* fix render bug in category

* take advantage of schema categories guarantee

* lint

* do not clear history when resetting

* enhanced annomatrix gc

* lint

* finish renaming to follow conventions; fix clone race bug

* lint

* add priority based loading to improve initial data load UX

* crossfilter cache perf

* perf tuning

* remove timers

* documentation

* PR review changes

* PR review changes

* more PR review edits

* improve clarity of comment

* more PR review fixes

* port centroidLabels to use react-async

* remove dead code

* pr review updates

* oops, remove logging

client/src/util/promiseLimit.js

@@ -12,19 +12,58 @@ return Promise.all([
 	plimit.add(() => fetch('/bar')),
 	plimit.add(() => fetch('/baz'))
 ])
+
+if you want a priority queue based implementation, just
+use priorityAdd() instead of add():
+
+const plimit = new PromiseLimit(2);
+return Promise.all([
+  plimit.priorityAdd(0, () => fetch('/foo')),
+  plimit.priorityAdd(10, () => fetch('/bar')),
+  plimit.priorityAdd(-1, () => fetch('/baz'))
+])
+
+Priority is a numeric value.  Lower first.  Stable ordering.
 */
+
+import TinyQueue from "tinyqueue";
+
+function compare(a, b) {
+  const diff = a.priority - b.priority;
+  if (diff) return diff;
+  return a.order - b.order;
+}
+
 export default class PromiseLimit {
-  constructor(maxConcurrency) {
-    this.queue = new Set();
+  constructor(maxConcurrency = 5) {
+    this.queue = new TinyQueue([], compare);
     this.maxConcurrency = maxConcurrency;
     this.pending = 0;
+    this.insertCounter = 0;
+  }
+
+  priorityAdd(p, fn, ...args) {
+    // p - numermic priority (lower first)
+    // fn - must return a promise
+    // args - will be passed to fn
+    return this._push(p, fn, args);
   }
 
   add(fn, ...args) {
     // fn - must return a promise
     // args - will be passed to fn
+    return this._push(0, fn, args);
+  }
+
+  /**
+  Private below
+  **/
+
+  _push(priority, fn, args) {
+    const order = this.insertCount;
+    this.insertCount += 1;
     return new Promise((resolve, reject) => {
-      this.queue.add({ fn, args, resolve, reject });
+      this.queue.push({ priority, order, fn, args, resolve, reject });
       this._resolveNext(false);
     });
   }
@@ -32,15 +71,17 @@ export default class PromiseLimit {
   _resolveNext = (completed = true) => {
     if (completed) this.pending -= 1;
 
-    while (this.queue.size > 0 && this.pending < this.maxConcurrency) {
-      const task = this.queue.values().next().value; // order of insertion
+    while (this.queue.length > 0 && this.pending < this.maxConcurrency) {
+      const task = this.queue.pop(); // order of insertion
       this.pending += 1;
-      this.queue.delete(task);
       const { resolve, reject, fn, args } = task;
 
       try {
         const result = fn(...args);
-        result.then(this._resolveNext, this._resolveNext);
+        result.then(
+          () => this._resolveNext(true),
+          () => this._resolveNext(true)
+        );
         result.then(resolve, reject);
       } catch (err) {
         reject(err);