@andrew_l/toolkit 0.3.1 → 0.3.21

package/dist/index.d.cts

@@ -4452,7 +4452,9 @@ declare const unset: (object: any, path: lodash.PropertyPath) => boolean;
  *
  * @group Promise
  */
-declare function asyncFilter<T>(array: T[], predicate: (value: T, index: number, array: Array<T>) => Promise<boolean> | boolean): Promise<T[]>;
+declare function asyncFilter<T>(array: T[], predicate: (value: T, index: number, array: Array<T>) => Promise<boolean> | boolean, { concurrency }?: {
+    concurrency?: number | undefined;
+}): Promise<T[]>;
 
 /**
  * Asynchronously finds the first element in an array that satisfies the provided async predicate.

package/dist/index.d.mts

@@ -4452,7 +4452,9 @@ declare const unset: (object: any, path: lodash.PropertyPath) => boolean;
  *
  * @group Promise
  */
-declare function asyncFilter<T>(array: T[], predicate: (value: T, index: number, array: Array<T>) => Promise<boolean> | boolean): Promise<T[]>;
+declare function asyncFilter<T>(array: T[], predicate: (value: T, index: number, array: Array<T>) => Promise<boolean> | boolean, { concurrency }?: {
+    concurrency?: number | undefined;
+}): Promise<T[]>;
 
 /**
  * Asynchronously finds the first element in an array that satisfies the provided async predicate.

package/dist/index.d.ts

@@ -4452,7 +4452,9 @@ declare const unset: (object: any, path: lodash.PropertyPath) => boolean;
  *
  * @group Promise
  */
-declare function asyncFilter<T>(array: T[], predicate: (value: T, index: number, array: Array<T>) => Promise<boolean> | boolean): Promise<T[]>;
+declare function asyncFilter<T>(array: T[], predicate: (value: T, index: number, array: Array<T>) => Promise<boolean> | boolean, { concurrency }?: {
+    concurrency?: number | undefined;
+}): Promise<T[]>;
 
 /**
  * Asynchronously finds the first element in an array that satisfies the provided async predicate.

package/dist/index.mjs

@@ -4750,28 +4750,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";
@@ -4791,6 +4769,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);
@@ -4815,35 +4832,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);
+    }
   });
 }
 
@@ -4984,38 +5002,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);
+    }
   });
 }