//Implementa la funzione // promiseAllLimit(tasks: Array<() => Promise<unknown>>, limit: number): Promise<any[]>, //che esegue promesse con un limite massimo di richieste simultanee.

La funzione promiseAllLimit consente di eseguire task (funzioni che restituiscono promesse) con una limitazione sul numero di promesse che possono essere eseguite contemporaneamente. Questo è utile, ad esempio, per non sovraccaricare la rete o l'API.

Esempio di implementazione:

function promiseAllLimit(tasks, limit) {
  return new Promise((resolve, reject) => {
    const results = [];
    let running = 0;
    let index = 0;
    let resolvedCount = 0;

    function runNext() {
      if (resolvedCount === tasks.length) {
        resolve(results);
        return;
      }

      while (running < limit && index < tasks.length) {
        const currentIndex = index;
        const task = tasks[currentIndex];
        index++;
        running++;

        task()
          .then(result => {
            results[currentIndex] = result;
          })
          .catch(err => {
            reject(err);
          })
          .finally(() => {
            running--;
            resolvedCount++;
            runNext();
          });
      }
    }

    runNext();
  });
}

Qui, avviamo fino a limit task contemporaneamente, e dopo ogni completamento avviamo il successivo, fino a processare tutti. I risultati vengono memorizzati in un array nell'ordine delle task originali.