Promise overlapping

HTML

<script src="debounce-promise"></script>

JavaScript

var counter = 0;
var lastFinishedId = -1;

function myLog(id, value){
	if (id <= lastFinishedId) return;
  lastFinishedId = id;
  console.log('Resolve:', value);
}

function expensiveOperation(value) {
  console.log('Create promise:', value);
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve(value);
    }, 1000*(5 - value));
  })
}

var saveCycles = debounce(expensiveOperation, 100);

[1, 2, 3, 4].forEach(num => {
  var id = counter++;
  return saveCycles(num).then(value => {
    myLog(id, value)
  })
})
setTimeout(() => {
  var id = counter++;
  saveCycles(5).then(value => {
    myLog(id, value)
  })
}, 200);





// debounce-promise lib

function debounce (fn, wait = 0, options = {}) {
  let lastCallAt
  let deferred
  let timer
  let pendingArgs = []
  return function debounced (...args) {
    const currentWait = getWait(wait)
    const currentTime = new Date().getTime()

    const isCold = !lastCallAt || (currentTime - lastCallAt) > currentWait

    lastCallAt = currentTime

    if (isCold && options.leading) {
      return options.accumulate
        ? Promise.resolve(fn.call(this, [args])).then(result => result[0])
        : Promise.resolve(fn.call(this, ...args))
    }

    if (deferred) {
      clearTimeout(timer)
    } else {
      deferred = defer()
    }

    pendingArgs.push(args)
    timer = setTimeout(flush.bind(this), currentWait)

    if (options.accumulate) {
      const argsIndex = pendingArgs.length - 1
      return deferred.promise.then(results => results[argsIndex])
    }

    return deferred.promise
  }

  function flush () {
    const thisDeferred = deferred
    clearTimeout(timer)

    Promise.resolve(
      options.accumulate
        ? fn.call(this, pendingArgs)
        : fn.apply(this, pendingArgs[pendingArgs.length - 1])
    )
      .then(thisDeferred.resolve, thisDeferred.reject)

    pendingArgs = []
    deferred = null
  }
}

function getWait (wait) {
  return (typeof wait === 'function') ? wait() :...