Bump to v4.7.0.

debounce.js

@@ -7,7 +7,8 @@ define(['./isObject', './now', './toNumber'], function(isObject, now, toNumber)
   var FUNC_ERROR_TEXT = 'Expected a function';
 
   /* Built-in method references for those with the same name as other `lodash` methods. */
-  var nativeMax = Math.max;
+  var nativeMax = Math.max,
+      nativeMin = Math.min;
 
   /**
    * Creates a debounced function that delays invoking `func` until after `wait`
@@ -28,16 +29,17 @@ define(['./isObject', './now', './toNumber'], function(isObject, now, toNumber)
    *
    * @static
    * @memberOf _
+   * @since 0.1.0
    * @category Function
    * @param {Function} func The function to debounce.
    * @param {number} [wait=0] The number of milliseconds to delay.
-   * @param {Object} [options] The options object.
-   * @param {boolean} [options.leading=false] Specify invoking on the leading
-   *  edge of the timeout.
-   * @param {number} [options.maxWait] The maximum time `func` is allowed to be
-   *  delayed before it's invoked.
-   * @param {boolean} [options.trailing=true] Specify invoking on the trailing
-   *  edge of the timeout.
+   * @param {Object} [options={}] The options object.
+   * @param {boolean} [options.leading=false]
+   *  Specify invoking on the leading edge of the timeout.
+   * @param {number} [options.maxWait]
+   *  The maximum time `func` is allowed to be delayed before it's invoked.
+   * @param {boolean} [options.trailing=true]
+   *  Specify invoking on the trailing edge of the timeout.
    * @returns {Function} Returns the new debounced function.
    * @example
    *
@@ -59,14 +61,12 @@ define(['./isObject', './now', './toNumber'], function(isObject, now, toNumber)
    * jQuery(window).on('popstate', debounced.cancel);
    */
   function debounce(func, wait, options) {
-    var args,
-        maxTimeoutId,
+    var lastArgs,
+        lastThis,
         result,
-        stamp,
-        thisArg,
-        timeoutId,
-        trailingCall,
-        lastCalled = 0,
+        timerId,
+        lastCallTime = 0,
+        lastInvokeTime = 0,
         leading = false,
         maxWait = false,
         trailing = true;
@@ -81,92 +81,94 @@ define(['./isObject', './now', './toNumber'], function(isObject, now, toNumber)
       trailing = 'trailing' in options ? !!options.trailing : trailing;
     }
 
-    function cancel() {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
-      if (maxTimeoutId) {
-        clearTimeout(maxTimeoutId);
-      }
-      lastCalled = 0;
-      args = maxTimeoutId = thisArg = timeoutId = trailingCall = undefined;
-    }
+    function invokeFunc(time) {
+      var args = lastArgs,
+          thisArg = lastThis;
 
-    function complete(isCalled, id) {
-      if (id) {
-        clearTimeout(id);
-      }
-      maxTimeoutId = timeoutId = trailingCall = undefined;
-      if (isCalled) {
-        lastCalled = now();
-        result = func.apply(thisArg, args);
-        if (!timeoutId && !maxTimeoutId) {
-          args = thisArg = undefined;
-        }
-      }
-    }
-
-    function delayed() {
-      var remaining = wait - (now() - stamp);
-      if (remaining <= 0 || remaining > wait) {
-        complete(trailingCall, maxTimeoutId);
-      } else {
-        timeoutId = setTimeout(delayed, remaining);
-      }
-    }
-
-    function flush() {
-      if ((timeoutId && trailingCall) || (maxTimeoutId && trailing)) {
-        result = func.apply(thisArg, args);
-      }
-      cancel();
+      lastArgs = lastThis = undefined;
+      lastInvokeTime = time;
+      result = func.apply(thisArg, args);
       return result;
     }
 
-    function maxDelayed() {
-      complete(trailing, timeoutId);
+    function leadingEdge(time) {
+      // Reset any `maxWait` timer.
+      lastInvokeTime = time;
+      // Start the timer for the trailing edge.
+      timerId = setTimeout(timerExpired, wait);
+      // Invoke the leading edge.
+      return leading ? invokeFunc(time) : result;
+    }
+
+    function remainingWait(time) {
+      var timeSinceLastCall = time - lastCallTime,
+          timeSinceLastInvoke = time - lastInvokeTime,
+          result = wait - timeSinceLastCall;
+
+      return maxWait === false ? result : nativeMin(result, maxWait - timeSinceLastInvoke);
+    }
+
+    function shouldInvoke(time) {
+      var timeSinceLastCall = time - lastCallTime,
+          timeSinceLastInvoke = time - lastInvokeTime;
+
+      // Either this is the first call, activity has stopped and we're at the
+      // trailing edge, the system time has gone backwards and we're treating
+      // it as the trailing edge, or we've hit the `maxWait` limit.
+      return (!lastCallTime || (timeSinceLastCall >= wait) ||
+        (timeSinceLastCall < 0) || (maxWait !== false && timeSinceLastInvoke >= maxWait));
+    }
+
+    function timerExpired() {
+      var time = now();
+      if (shouldInvoke(time)) {
+        return trailingEdge(time);
+      }
+      // Restart the timer.
+      timerId = setTimeout(timerExpired, remainingWait(time));
+    }
+
+    function trailingEdge(time) {
+      clearTimeout(timerId);
+      timerId = undefined;
+
+      // Only invoke if we have `lastArgs` which means `func` has been
+      // debounced at least once.
+      if (trailing && lastArgs) {
+        return invokeFunc(time);
+      }
+      lastArgs = lastThis = undefined;
+      return result;
+    }
+
+    function cancel() {
+      if (timerId !== undefined) {
+        clearTimeout(timerId);
+      }
+      lastCallTime = lastInvokeTime = 0;
+      lastArgs = lastThis = timerId = undefined;
+    }
+
+    function flush() {
+      return timerId === undefined ? result : trailingEdge(now());
     }
 
     function debounced() {
-      args = arguments;
-      stamp = now();
-      thisArg = this;
-      trailingCall = trailing && (timeoutId || !leading);
+      var time = now(),
+          isInvoking = shouldInvoke(time);
 
-      if (maxWait === false) {
-        var leadingCall = leading && !timeoutId;
-      } else {
-        if (!lastCalled && !maxTimeoutId && !leading) {
-          lastCalled = stamp;
-        }
-        var remaining = maxWait - (stamp - lastCalled);
+      lastArgs = arguments;
+      lastThis = this;
+      lastCallTime = time;
 
-        var isCalled = (remaining <= 0 || remaining > maxWait) &&
-          (leading || maxTimeoutId);
-
-        if (isCalled) {
-          if (maxTimeoutId) {
-            maxTimeoutId = clearTimeout(maxTimeoutId);
-          }
-          lastCalled = stamp;
-          result = func.apply(thisArg, args);
+      if (isInvoking) {
+        if (timerId === undefined) {
+          return leadingEdge(lastCallTime);
         }
-        else if (!maxTimeoutId) {
-          maxTimeoutId = setTimeout(maxDelayed, remaining);
-        }
-      }
-      if (isCalled && timeoutId) {
-        timeoutId = clearTimeout(timeoutId);
-      }
-      else if (!timeoutId && wait !== maxWait) {
-        timeoutId = setTimeout(delayed, wait);
-      }
-      if (leadingCall) {
-        isCalled = true;
-        result = func.apply(thisArg, args);
-      }
-      if (isCalled && !timeoutId && !maxTimeoutId) {
-        args = thisArg = undefined;
+        // Handle invocations in a tight loop.
+        clearTimeout(timerId);
+        timerId = setTimeout(timerExpired, wait);
+        return invokeFunc(lastCallTime);
       }
       return result;
     }