ui/common throttlePromiseWithResult

ui/analyse/src/study/studyCtrl.ts

@@ -638,7 +638,7 @@ export default class StudyCtrl {
         (position.path === this.ctrl.path && position.path === treePath.fromNodeList(this.ctrl.mainline))
       )
         this.ctrl.jump(newPath);
-      this.redraw();
+      return this.redraw();
     },
     deleteNode: d => {
       const position = d.p,
@@ -650,7 +650,7 @@ export default class StudyCtrl {
       if (!this.ctrl.tree.pathExists(d.p.path)) return this.xhrReload();
       this.ctrl.tree.deleteNodeAt(position.path);
       if (this.vm.mode.sticky) this.ctrl.jump(this.ctrl.path);
-      this.redraw();
+      return this.redraw();
     },
     promote: d => {
       const position = d.p,
@@ -663,7 +663,7 @@ export default class StudyCtrl {
       if (this.vm.mode.sticky) this.ctrl.jump(this.ctrl.path);
       else if (this.relay) this.ctrl.jump(d.p.path);
       this.ctrl.treeVersion++;
-      this.redraw();
+      return this.redraw();
     },
     reload: this.xhrReload,
     changeChapter: d => {

ui/common/src/throttle.ts

@@ -3,25 +3,61 @@
  * flight. Any extra calls are dropped, except the last one, which waits for
  * the previous call to complete.
  */
-export function throttlePromise<T extends (...args: any) => Promise<any>>(
+export function throttlePromiseWithResult<R, T extends (...args: any) => Promise<R>>(
   wrapped: T,
-): (...args: Parameters<T>) => void {
-  let current: Promise<void> | undefined;
-  let afterCurrent: (() => void) | undefined;
+): (...args: Parameters<T>) => Promise<R> {
+  let current: Promise<R> | undefined;
+  let pending:
+    | {
+        run: () => Promise<R>;
+        reject: () => void;
+      }
+    | undefined;
 
-  return function (this: any, ...args: Parameters<T>): void {
+  return function (this: any, ...args: Parameters<T>): Promise<R> {
     const self = this;
 
-    const exec = () => {
-      afterCurrent = undefined;
+    const runCurrent = () => {
       current = wrapped.apply(self, args).finally(() => {
         current = undefined;
-        if (afterCurrent) afterCurrent();
+        if (pending) {
+          pending.run();
+          pending = undefined;
+        }
       });
+      return current;
     };
 
-    if (current) afterCurrent = exec;
-    else exec();
+    if (!current) return runCurrent();
+
+    pending?.reject();
+    const next = new Promise<R>((resolve, reject) => {
+      pending = {
+        run: () =>
+          runCurrent().then(
+            res => {
+              resolve(res);
+              return res;
+            },
+            err => {
+              reject(err);
+              throw err;
+            },
+          ),
+        reject: () => reject(new Error('Throttled')),
+      };
+    });
+    return next;
+  };
+}
+
+/* doesn't fail the promise if it's throttled */
+export function throttlePromise<T extends (...args: any) => Promise<void>>(
+  wrapped: T,
+): (...args: Parameters<T>) => Promise<void> {
+  const throttler = throttlePromiseWithResult<void, T>(wrapped);
+  return function (this: any, ...args: Parameters<T>): Promise<void> {
+    return throttler.apply(this, args).catch(() => {});
   };
 }
 
@@ -49,7 +85,7 @@ export function finallyDelay<T extends (...args: any) => Promise<any>>(
 export function throttlePromiseDelay<T extends (...args: any) => Promise<any>>(
   delay: (...args: Parameters<T>) => number,
   wrapped: T,
-): (...args: Parameters<T>) => void {
+): (...args: Parameters<T>) => Promise<void> {
   return throttlePromise(finallyDelay(delay, wrapped));
 }