//Implémentez la fonction // promiseAllLimit(tasks: Array<() => Promise<unknown>>, limit: number): Promise<any[]>, //qui exécute des promesses avec une limite sur le nombre maximum de requêtes simultanées.

La fonction promiseAllLimit permet d'exécuter des tâches (fonctions renvoyant des promesses) avec une limite sur le nombre de promesses en cours d'exécution simultanément. Cela est utile, par exemple, pour ne pas surcharger le réseau ou l'API.

Exemple d'implémentation :

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();
  });
}

Ici, nous lançons jusqu'à limit tâches en même temps, et après chaque complétion, nous lançons la suivante, jusqu'à traiter toutes. Les résultats sont stockés dans un tableau dans l'ordre des tâches originales.