a debounce that summarizes instead of throwing away information from frequent function calls.

burst.ls

# Think of this as a debounce that remembers intermediate calls and summarizes them instead of throwing them away.
#
# @param {Function} initial-fn        function that returns initial-state for use with fold and combiner-fn
# @param {Function} combiner-fn       given an array of arrays of function arguments, fold them into a value that can be used by final-fn
# @param {Function} final-fn          function to run after nothing has happend for longer than delay milliseconds
# @param {Number}   delay             milliseconds to wait for inactivity before running final-fn
export burst = (initial-fn, combiner-fn, final-fn, delay) ->
  ax           = []
  accumulating = false
  wait         = null
  finish = ->
    initial-value = initial-fn!
    final = fold combiner-fn, initial-value, ax
    final-fn(final)
    ax           := []
    accumulating := false
    wait         := null

  (...args) ->
    if not accumulating
      accumulating := true
    else
      clear-timeout(wait) if wait
      wait := set-timeout finish, delay
    ax.push args