@andrew_l/toolkit 0.3.1 → 0.3.21

package/dist/index.cjs

@@ -4761,28 +4761,6 @@ const logger = (...baseArgs) => {
   return instance;
 };
 
-function asyncFilter(array, predicate) {
-  var i = 0;
-  var result = [];
-  var cooldown = nextTickIteration(10);
-  return new Promise((resolve, reject) => {
-    var processNextBatch = () => {
-      if (i < array.length) {
-        cooldown().then(() => predicate(array[i], i, array)).then((valid) => {
-          if (Boolean(valid)) {
-            result.push(array[i]);
-          }
-          i++;
-          setTimeout(processNextBatch, 0);
-        }).catch(reject);
-      } else {
-        resolve(result);
-      }
-    };
-    processNextBatch();
-  });
-}
-
 function nextTickIteration(amount, delay = "tick") {
   let counter = 0;
   const tickInterval = delay === "tick";
@@ -4802,6 +4780,45 @@ function nextTickIteration(amount, delay = "tick") {
   };
 }
 
+function asyncFilter(array, predicate, { concurrency = 1 } = {}) {
+  concurrency = Math.max(concurrency, 1);
+  if (array.length === 0) {
+    return Promise.resolve([]);
+  }
+  var result = [];
+  var currentIndex = 0;
+  var completed = 0;
+  var hasError = false;
+  var cooldown = nextTickIteration(10);
+  return new Promise((resolve, reject) => {
+    var processItem = (index) => {
+      if (hasError || index >= array.length) return;
+      cooldown().then(() => predicate(array[index], index, array)).then((include) => {
+        if (hasError) return;
+        if (include) {
+          result.push(index);
+        }
+        completed++;
+        if (completed >= array.length) {
+          resolve(result.toSorted((a, b) => a - b).map((idx) => array[idx]));
+        } else {
+          if (currentIndex < array.length) {
+            processItem(currentIndex++);
+          }
+        }
+      }).catch((error) => {
+        if (!hasError) {
+          hasError = true;
+          reject(error);
+        }
+      });
+    };
+    for (; currentIndex < concurrency; currentIndex++) {
+      processItem(currentIndex);
+    }
+  });
+}
+
 function asyncFind(array, callbackfn) {
   var i = 0;
   var cooldown = nextTickIteration(10);
@@ -4826,35 +4843,36 @@ function asyncFind(array, callbackfn) {
 
 function asyncForEach(array, callbackfn, { concurrency = 1 } = {}) {
   concurrency = Math.max(concurrency, 1);
-  var i = 0;
+  if (array.length === 0) {
+    return Promise.resolve();
+  }
+  var hasError = false;
+  var completed = 0;
+  var currentIndex = 0;
   var cooldown = nextTickIteration(10);
-  var tasks = Array(concurrency);
   return new Promise((resolve, reject) => {
-    var processNextBatch = () => {
-      if (i >= array.length) {
-        resolve();
-        return;
-      }
-      cooldown().then(() => {
-        for (var idx = 0; idx < concurrency; idx++) {
-          tasks[idx] = Promise.resolve(i);
-          if (i < array.length) {
-            tasks[idx] = tasks[idx].then(
-              (itemIndex) => callbackfn(array[itemIndex], itemIndex, array)
-            );
+    var processItem = (index) => {
+      if (hasError || index >= array.length) return;
+      cooldown().then(() => callbackfn(array[index], index, array)).then((transformed) => {
+        if (hasError) return;
+        completed++;
+        if (completed >= array.length) {
+          resolve();
+        } else {
+          if (currentIndex < array.length) {
+            processItem(currentIndex++);
           }
-          i++;
         }
-        return Promise.all(tasks);
-      }).then(() => {
-        if (i < array.length) {
-          setTimeout(processNextBatch, 0);
-        } else {
-          resolve();
+      }).catch((error) => {
+        if (!hasError) {
+          hasError = true;
+          reject(error);
         }
-      }).catch(reject);
+      });
     };
-    processNextBatch();
+    for (; currentIndex < concurrency; currentIndex++) {
+      processItem(currentIndex);
+    }
   });
 }
 
@@ -4995,38 +5013,38 @@ class AsyncIterableQueue {
 
 function asyncMap(array, callbackfn, { concurrency = 1 } = {}) {
   concurrency = Math.max(concurrency, 1);
-  var result = [];
-  var i = 0;
+  if (array.length === 0) {
+    return Promise.resolve([]);
+  }
+  var hasError = false;
+  var result = Array(array.length);
+  var completed = 0;
+  var currentIndex = 0;
   var cooldown = nextTickIteration(10);
-  var tasks = Array(concurrency);
   return new Promise((resolve, reject) => {
-    var processNextBatch = () => {
-      if (i >= array.length) {
-        resolve(result);
-      } else {
-        cooldown().then(() => {
-          for (var idx = 0; idx < concurrency; idx++) {
-            tasks[idx] = Promise.resolve(i);
-            if (i < array.length) {
-              tasks[idx] = tasks[idx].then(
-                (itemIndex) => callbackfn(array[itemIndex], itemIndex, array)
-              ).then((transformed) => {
-                result.push(transformed);
-              });
-            }
-            i++;
-          }
-          return Promise.all(tasks);
-        }).then(() => {
-          if (i < array.length) {
-            setTimeout(processNextBatch, 0);
-          } else {
-            resolve(result);
+    var processItem = (index) => {
+      if (hasError || index >= array.length) return;
+      cooldown().then(() => callbackfn(array[index], index, array)).then((transformed) => {
+        if (hasError) return;
+        result[index] = transformed;
+        completed++;
+        if (completed >= array.length) {
+          resolve(result);
+        } else {
+          if (currentIndex < array.length) {
+            processItem(currentIndex++);
           }
-        }).catch(reject);
-      }
+        }
+      }).catch((error) => {
+        if (!hasError) {
+          hasError = true;
+          reject(error);
+        }
+      });
     };
-    processNextBatch();
+    for (; currentIndex < concurrency; currentIndex++) {
+      processItem(currentIndex);
+    }
   });
 }