I'm happy to try any new asyncThrottle implementation

if you have a better implementation that is also correct, please do contribute 🙏. The asyncThrottle function does have a decent test coverage.

Maybe we can also get inspired by other, already existing implementations?

• https://github.com/sindresorhus/p-throttle

@Jack-Works would you consider contributing your patch back to the persister plugin?

• https://github.com/DimensionDev/Maskbook/pull/11227/files

@Jack-Works would you consider contributing your patch back to the persister plugin?

* [DimensionDev/Maskbook#11227 (files)](https://github.com/DimensionDev/Maskbook/pull/11227/files)

Hi! I think our patch is obviously imperfect (it is over simplified and maybe even incorrect). I hope your team can find another throttle implementation and I'd like to try it.

Maybe we can also get inspired by other, already existing implementations?

[sindresorhus/p-throttle](https://github.com/sindresorhus/p-throttle)

@TkDodo Genuine question: why don't you use p-throttle? :) I'm just trying to understand what makes asyncThrottle special.

Hello @jhnns,

I was also wondering why not just use p-throttle, so I looked into the two implementations and they don't actually behave the same.

Take the following example:

const start = performance.now();
const fn = (a, b) => {
  const time = Math.floor(performance.now() - start);
  const result = a + b;
  console.log({ time, result });
};

const throttledFn = asyncThrottle(fn, { interval: 500 });

throttledFn(1, 2); // prints: { time: 0, result: 3 }
throttledFn(1, 3); // ignored
throttledFn(1, 4); // ignored
throttledFn(1, 5); // ignored
throttledFn(1, 6); // prints: { time: 500, result: 7 }

So to my understanding, asyncThrottle only keeps the last call waiting and ignores all the other calls.

While p-throttle keeps all the calls waiting and executes them in order:

import pThrottle from "p-throttle";

const start = performance.now();
const fn = (a, b) => {
  const time = Math.floor(performance.now() - start);
  const result = a + b;
  console.log({ time, result });
};
const throttle = pThrottle({
  limit: 1,
  interval: 500,
});
const throttledFn = throttle(fn, { interval: 500 });

throttledFn(1, 2); // prints: { time: 0, result: 3 }
throttledFn(1, 3); // prints: { time: 500, result: 4 }
throttledFn(1, 4); // prints: { time: 1000, result: 5 }
throttledFn(1, 5); // prints: { time: 1500, result: 6 }
throttledFn(1, 6); // prints: { time: 2000, result: 7 }

I didn't find a way to tell p-throttle to only keep the last call, so I don't think it can be used as a drop-in replacement for asyncThrottle.

@Jack-Works I made the PR #7224 that suggests a new implementation. Can you please try it on your project and let us know if it fixes the issue?

fixed by:

• perf(asyncThrottle): Improve performance #7224