avoid creating runloop for debounce and throttle

Author: bekzod

lib/backburner/binary-search.ts

@@ -1,24 +1,24 @@
 export default function binarySearch(time, timers) {
   let start = 0;
-  let end = timers.length - 6;
+  let end = timers.length - 7;
   let middle;
   let l;
 
   while (start < end) {
     // since timers is an array of pairs 'l' will always
     // be an integer
-    l = (end - start) / 6;
+    l = (end - start) / 7;
 
     // compensate for the index in case even number
     // of pairs inside timers
-    middle = start + l - (l % 6);
+    middle = start + l - (l % 7);
 
     if (time >= timers[middle]) {
-      start = middle + 6;
+      start = middle + 7;
     } else {
       end = middle;
     }
   }
 
-  return (time >= timers[start]) ? start + 6 : start;
+  return (time >= timers[start]) ? start + 7 : start;
 }

lib/backburner/utils.ts

@@ -22,12 +22,12 @@ export function findItem(target, method, collection) {
   return index;
 }
 
-export function findTimer(timer, collection) {
+export function findTimerItem(target, method, collection) {
   let index = -1;
 
-  for (let i = 3; i < collection.length; i += 4) {
-    if (collection[i] === timer) {
-      index = i - 3;
+  for (let i = 2, l = collection.length; i < l; i += 7) {
+    if (collection[i] === target && collection[i + 1] === method) {
+      index = i - 2;
       break;
     }
   }

lib/index.ts

@@ -8,8 +8,7 @@ import {
   IPlatform,
 } from './backburner/platform';
 import {
-  findItem,
-  findTimer,
+  findTimerItem,
   getOnError,
   isCoercableNumber
 } from './backburner/utils';
@@ -193,8 +192,6 @@ export default class Backburner {
   private _onEnd: (currentInstance: DeferredActionQueues, nextInstance: DeferredActionQueues | null) => void;
   private queueNames: string[];
   private instanceStack: DeferredActionQueues[] = [];
-  private _debouncees: any[] = [];
-  private _throttlers: any[] = [];
   private _eventCallbacks: {
     end: Function[];
     begin: Function[];
@@ -450,26 +447,21 @@ export default class Backburner {
     throttleCount++;
     let [target, method, args, wait, isImmediate = true] = parseDebounceArgs(...arguments);
 
-    let index = findItem(target, method, this._throttlers);
+    let index = findTimerItem(target, method, this._timers);
     if (index > -1) {
-      this._throttlers[index + 2] = args;
-      return this._throttlers[index + 3];
-    } // throttled
+      let timerId = this._timers[index + 1];
+      this._timers[index + 4] = args;
+      return timerId;
+    }
 
-    let timer = this._platform.setTimeout(() => {
-      let i = findTimer(timer, this._throttlers);
-      let [context, func, params] = this._throttlers.splice(i, 4);
-      if (isImmediate === false) {
-        this._run(context, func, params);
-      }
-    }, wait);
+    wait = parseInt(wait, 10);
+
+    let timer = this._later(target, method, args, wait, isImmediate);
 
     if (isImmediate) {
       this._join(target, method, args);
     }
 
-    this._throttlers.push(target, method, args, timer);
-
     return timer;
   }
 
@@ -495,64 +487,40 @@ export default class Backburner {
     let [target, method, args, wait, isImmediate = false] = parseDebounceArgs(...arguments);
 
     // Remove debouncee
-    let index = findItem(target, method, this._debouncees);
+    let index = findTimerItem(target, method, this._timers);
     if (index > -1) {
-      let timerId = this._debouncees[index + 3];
-      this._platform.clearTimeout(timerId);
-      this._debouncees.splice(index, 4);
+      this._timers.splice(index, 7);
+      if (index === 0) {
+        this._reinstallTimerTimeout();
+      }
     }
 
-    let timer = this._platform.setTimeout(() => {
-      let i = findTimer(timer, this._debouncees);
-      let [context, func, params] = this._debouncees.splice(i, 4);
-      if (isImmediate === false) {
-        this._run(context, func, params);
-      }
-    }, wait);
+    let timer = this._later(target, method, args, wait, isImmediate);
 
     if (isImmediate && index === -1) {
       this._join(target, method, args);
     }
 
-    this._debouncees.push(target, method, args, timer);
-
     return timer;
   }
 
   public cancelTimers() {
     cancelTimersCount++;
-    for (let i = 3; i < this._throttlers.length; i += 4) {
-      this._platform.clearTimeout(this._throttlers[i]);
-    }
-    this._throttlers = [];
-
-    for (let t = 3; t < this._debouncees.length; t += 4) {
-      this._platform.clearTimeout(this._debouncees[t]);
-    }
-    this._debouncees = [];
-
     this._clearTimerTimeout();
     this._timers = [];
-
     this._cancelAutorun();
   }
 
   public hasTimers() {
-    return this._timers.length > 0 ||
-       this._debouncees.length > 0 ||
-       this._throttlers.length > 0 ||
-       this._autorun !== null;
+    return this._timers.length > 0 || this._autorun !== null;
   }
 
   public cancel(timer?) {
     cancelCount++;
-
-    if (timer === undefined || timer === null) { return false; }
-
+    if (timer === null || timer === undefined) { return false; }
     let timerType = typeof timer;
-    if (timerType === 'number') { // we're cancelling a throttle or debounce
-      return this._cancelItem(timer, this._throttlers) || this._cancelItem(timer, this._debouncees);
-    } else if (timerType === 'string') { // we're cancelling a setTimeout
+
+    if (timerType === 'number') { // we're cancelling a setTimeout or throttle or debounce
       return this._cancelLaterTimer(timer);
     } else if (timerType === 'object' && timer.queue && timer.method) { // we're cancelling a deferOnce
       return timer.queue.cancel(timer);
@@ -640,18 +608,18 @@ export default class Backburner {
     }
   }
 
-  private _later(target, method, args, wait) {
+  private _later(target, method, args, wait, isImmediate = false) {
     let stack = this.DEBUG ? new Error() : undefined;
     let executeAt = this._platform.now() + wait;
-    let id = (UUID++) + '';
+    let id = UUID++;
 
     if (this._timers.length === 0) {
-      this._timers.push(executeAt, id, target, method, args, stack);
+      this._timers.push(executeAt, id, target, method, args, isImmediate, stack);
       this._installTimerTimeout();
     } else {
       // find position to insert
       let i = searchTimer(executeAt, this._timers);
-      this._timers.splice(i, 0, executeAt, id, target, method, args, stack);
+      this._timers.splice(i, 0, executeAt, id, target, method, args, isImmediate, stack);
 
       // we should be the new earliest timer if i == 0
       if (i === 0) {
@@ -662,10 +630,10 @@ export default class Backburner {
   }
 
   private _cancelLaterTimer(timer) {
-    for (let i = 1; i < this._timers.length; i += 6) {
+    for (let i = 1; i < this._timers.length; i += 7) {
       if (this._timers[i] === timer) {
         i = i - 1;
-        this._timers.splice(i, 6);
+        this._timers.splice(i, 7);
         if (i === 0) {
           this._reinstallTimerTimeout();
         }
@@ -675,17 +643,6 @@ export default class Backburner {
     return false;
   }
 
-  private _cancelItem(timer, array) {
-    let index = findTimer(timer, array);
-
-    if (index > -1) {
-      this._platform.clearTimeout(timer);
-      array.splice(index, 4);
-      return true;
-    }
-    return false;
-  }
-
   /**
    Trigger an event. Supports up to two arguments. Designed around
    triggering transition events from one run loop instance to the
@@ -723,15 +680,17 @@ export default class Backburner {
     let defaultQueue = this._defaultQueue;
     let n = this._platform.now();
 
-    for (; i < l; i += 6) {
+    for (; i < l; i += 7) {
       let executeAt = timers[i];
       if (executeAt > n) { break; }
-
-      let target = timers[i + 2];
-      let method = timers[i + 3];
-      let args = timers[i + 4];
-      let stack = timers[i + 5];
-      this.currentInstance!.schedule(defaultQueue, target, method, args, false, stack);
+      let isImmediate = timers[i + 5];
+      if (isImmediate === false) {
+        let target = timers[i + 2];
+        let method = timers[i + 3];
+        let args = timers[i + 4];
+        let stack = timers[i + 6];
+        this.currentInstance!.schedule(defaultQueue, target, method, args, false, stack);
+      }
     }
 
     timers.splice(0, i);

tests/bb-has-timers-test.ts

@@ -17,6 +17,7 @@ QUnit.test('hasTimers', function(assert) {
     assert.ok(bb.hasTimers(), 'hasTimers checks timers');
 
     bb.cancel(timer);
+
     assert.ok(!bb.hasTimers(), 'Timers are cleared');
 
     timer = bb.debounce(target, 'fn', 200);