Can lodash debounce cancel a leading-edge invocation before it executes?

Answer

No. The .cancel() method on a lodash debounced function can only prevent the trailing‑edge call; it cannot stop a leading‑edge invocation that has already begun because the leading call runs synchronously before the wrapper returns control to the caller.

Confirmed facts

• When leading: true is set, the first call to the debounced wrapper executes the target function immediately, synchronously.
• The .cancel() method clears the internal timeout that drives the trailing‑edge call; it does not affect any function that is already executing.
• Calling .cancel() after the leading edge has started leaves that execution unchanged; it only prevents any subsequent trailing call.

Likely explanation

The leading‑edge behavior is implemented by invoking the original function directly inside the wrapper before any timer is set. Because that invocation happens on the same call stack as the debounced call, there is no asynchronous timer to clear, so .cancel() has nothing to cancel.

Steps to achieve full cancellation

1. If you need the ability to cancel a leading call, avoid leading: true and handle the leading edge manually.
2. Create a wrapper that tracks a cancellation flag:

function cancellableDebounce(func, wait, options) {
  const debounced = _.debounce(func, wait, options);
  let cancelled = false;
  const wrapped = function (...args) {
    if (cancelled) return;
    return debounced.apply(this, args);
  };
  wrapped.cancel = () => {
    cancelled = true;
    debounced.cancel();
  };
  return wrapped;
}

3. Use the returned wrapper; calling its .cancel() sets the flag and clears the timer, preventing both leading and trailing executions.

Missing diagnostic detail

To confirm whether the above pattern fits your code, can you modify or wrap the original function (i.e., do you have control over the function passed to _.debounce)?