Having an option to call the function immediately could be useful but it would require changing the API because currently all parameters are being passed into fn. There would be a bit of weirdness with creating value for multi parameter functions so feedback on how to make that work would be appreciated. I don't have a specific use case for this but I saw it while doing research. Could be useful in sindresorhus/debounce-fn as well but faces same problem.

Here is what I was thinking:

pDebounce(fn, wait, options?)

.....

pDebounce()(value, immediate?)

value

Type: any

The value to be passed to fn, the function being debounced.

immediate

Type: boolean
Default: false

If false, debounce will follow normal behavior. If true the debounced function will be called immediately.

Hello!

I'm a huge fan of your work and use got everywhere I go.

Use case: I don't transpile my code or use typescript; I make use require-in-the-middle and cannot easily switch my type in package.json to module nor change all of my require to import.

I'm not seeing a way to use this module in Node 14 unless my project is 100% ESM and/or using Babel.

Am I missing something?

Thanks for your great work!

Thank you for this awesome solution for debouncing Promises!

How should this library be used together with p-cancelable?

To match the wording of sindresorhus/debounce-fn@689f847

I created something very similar to this package, the only difference is that, when the async function is not called due to debounce timer, the related Promise is rejected with a default object value.

That was done to be used in scenarios like the following.
I have an input element, whose 'change' event is bound to a callback that makes an API call and, then, updates the DOM. This callback needs to be debounced to prevent overloading the server with multiple calls.

// pseudocode
inputEl.addEventListener('change', (e) => {
   callApiDebounced(e.target.value).then(updateDOM)
})

With the actual implementation of p-debounce, multiple calls to the debounced functions would result in multiple updates to the DOM (with the same content). This could be prevented by resolving only the last Promise returned.

I'm wondering if this use case could be useful for other people.

Hi!

Maybe this is out of scope, but how could we support debouncing function calls only with the same arguments?

Would you be open to a PR for this, or should I be using something different? Thanks!

I was not sure if the example was wrong or if I was just dumb:

import pDebounce from 'p-debounce';

const expensiveCall = async (input) => input;

const debouncedFn = pDebounce(expensiveCall, 200);

for (const number of [1, 2, 3]) {
  console.log(await debouncedFn(number));
}

outputs:

1
2
3

README says:

3
3
3

Also I'm not sure this example demonstrates the value of the lib. Calling expensiveCall alone in the for loop would produce the same output.

There is this example in README (link):

import {setTimeout as delay} from 'timers/promises';
import pDebounce from 'p-debounce';

const expensiveCall = async value => {
	await delay(200);
	return value;
}

const debouncedFn = pDebounce.promise(expensiveCall);

for (const number of [1, 2, 3]) {
	console.log(await debouncedFn(number));
}
//=> 3
//=> 3
//=> 3

Actual output:

1
2
3

I would like to debounce a function returning a promise but also limit the concurrent calls of my function to 1. That is, if a previous invocation is still running after the debounce delay is reached, delay again and again... until the last call finish and the debounce delay is expired (no other calls occured during the waiting time).

I know you also developed another module to limit conccurency, but I don't think I can combine it with this one to obtain the behavior I need. In my use case (an async database update), it's important that the last call occur ;)

Like sindresorhus/debounce-fn#9

Semi-related #10

I am wondering if exception handling could be added to this library? And if so, what the policy should be about rejecting the waiting promises? If all of them are rejected, then it will look like the error happened many times?

This source code uses arrow functions (and possibly other ES6 features, I didn't look too closely), which means it is not compatible with browser environments where IE11 support is required.