Throttle with trailing call preservation

throttleBoss.js

// This is a typical throttle implementation with the difference that it doesn't discard
// the final invocation - instead it runs it at the next valid timeslice.

throttleBoss: function(callback, delay) {
    var ready = true,
        args = null;

    return function throttled() {
        var context = this;

        if (ready) {
            ready = false;

            setTimeout(function() {
                ready = true;

                if (args) {
                    throttled.apply(context);
                }
            }, delay);

            if (args) {
                callback.apply(this, args);
                args = null;
            } else {
                callback.apply(this, arguments);
            }
        } else {
            args = arguments;
        }
    };
}

One significant issue with this implementation is that it won't work for throttled functions that receive no arguments.

With an implementation that fixes this issue, my vote is we simply call it throttle. Is there reason to have both this implementation and the existing throttle implementation?

Goal: a throttle method for rapid event handlers, such as mousemove and scroll.

Presumed desirable traits:

1. Responsive: execute the first invocation without delay; execute other eligible invocations with minimal delay
2. Accurate: ensure that trailing invocations during the timeout period are not discarded when the event ceases to be triggered
3. Performant: of course, throttling should happen for performance, also the manner of throttling should incur minimal overhead

throttle

Trailing invocations are discarded

01234512345123
0    5    5

throttleAfter

Initial invocation and trailing invocations are discarded

1234512345123
    5    5

throttleBoss

Final trailing invocation executes at next eligibile timeslice

01234512345123
0    5    5    3