@fuzdev/fuz_util 0.45.2 → 0.45.3

package/dist/async.d.ts

@@ -19,6 +19,24 @@ export interface Deferred<T> {
  * Creates a object with a `promise` and its `resolve`/`reject` handlers.
  */
 export declare const create_deferred: <T>() => Deferred<T>;
+/**
+ * Runs an async function on each item with controlled concurrency.
+ * Like `map_concurrent` but doesn't collect results (more efficient for side effects).
+ *
+ * @param items array of items to process
+ * @param fn async function to apply to each item
+ * @param concurrency maximum number of concurrent operations
+ *
+ * @example
+ * ```ts
+ * await each_concurrent(
+ *   file_paths,
+ *   async (path) => { await unlink(path); },
+ *   5, // max 5 concurrent deletions
+ * );
+ * ```
+ */
+export declare const each_concurrent: <T>(items: Array<T>, fn: (item: T, index: number) => Promise<void>, concurrency: number) => Promise<void>;
 /**
  * Maps over items with controlled concurrency, preserving input order.
  *

package/dist/async.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"async.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/async.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,IAAI,GAAI,iBAAY,KAAG,OAAO,CAAC,IAAI,CACQ,CAAC;AAEzD;;GAEG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,OAAO,CAAC,OAAO,CACI,CAAC;AAEzE;;GAEG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC;IAC1B,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IACpB,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IAC5B,MAAM,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,IAAI,CAAC;CAC9B;AAED;;GAEG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,OAAK,QAAQ,CAAC,CAAC,CAQ/C,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,cAAc,GAAU,CAAC,EAAE,CAAC,EACxC,OAAO,KAAK,CAAC,CAAC,CAAC,EACf,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,EAC1C,aAAa,MAAM,KACjB,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAoDlB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,sBAAsB,GAAU,CAAC,EAAE,CAAC,EAChD,OAAO,KAAK,CAAC,CAAC,CAAC,EACf,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,EAC1C,aAAa,MAAM,KACjB,OAAO,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC,CA6CxC,CAAC"}
+{"version":3,"file":"async.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/async.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,IAAI,GAAI,iBAAY,KAAG,OAAO,CAAC,IAAI,CACQ,CAAC;AAEzD;;GAEG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,OAAO,CAAC,OAAO,CACI,CAAC;AAEzE;;GAEG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC;IAC1B,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IACpB,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IAC5B,MAAM,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,IAAI,CAAC;CAC9B;AAED;;GAEG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,OAAK,QAAQ,CAAC,CAAC,CAQ/C,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,eAAe,GAAU,CAAC,EACtC,OAAO,KAAK,CAAC,CAAC,CAAC,EACf,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,EAC7C,aAAa,MAAM,KACjB,OAAO,CAAC,IAAI,CAgDd,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,cAAc,GAAU,CAAC,EAAE,CAAC,EACxC,OAAO,KAAK,CAAC,CAAC,CAAC,EACf,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,EAC1C,aAAa,MAAM,KACjB,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAkDlB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,sBAAsB,GAAU,CAAC,EAAE,CAAC,EAChD,OAAO,KAAK,CAAC,CAAC,CAAC,EACf,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,EAC1C,aAAa,MAAM,KACjB,OAAO,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC,CA6CxC,CAAC"}

package/dist/async.js

@@ -18,6 +18,68 @@ export const create_deferred = () => {
     });
     return { promise, resolve, reject };
 };
+/**
+ * Runs an async function on each item with controlled concurrency.
+ * Like `map_concurrent` but doesn't collect results (more efficient for side effects).
+ *
+ * @param items array of items to process
+ * @param fn async function to apply to each item
+ * @param concurrency maximum number of concurrent operations
+ *
+ * @example
+ * ```ts
+ * await each_concurrent(
+ *   file_paths,
+ *   async (path) => { await unlink(path); },
+ *   5, // max 5 concurrent deletions
+ * );
+ * ```
+ */
+export const each_concurrent = async (items, fn, concurrency) => {
+    if (concurrency < 1) {
+        throw new Error('concurrency must be at least 1');
+    }
+    let next_index = 0;
+    let active_count = 0;
+    let rejected = false;
+    return new Promise((resolve, reject) => {
+        const run_next = () => {
+            // Stop spawning if we've rejected
+            if (rejected)
+                return;
+            // Check if we're done
+            if (next_index >= items.length && active_count === 0) {
+                resolve();
+                return;
+            }
+            // Spawn workers up to concurrency limit
+            while (active_count < concurrency && next_index < items.length) {
+                const index = next_index++;
+                const item = items[index];
+                active_count++;
+                fn(item, index)
+                    .then(() => {
+                    if (rejected)
+                        return;
+                    active_count--;
+                    run_next();
+                })
+                    .catch((error) => {
+                    if (rejected)
+                        return;
+                    rejected = true;
+                    reject(error); // eslint-disable-line @typescript-eslint/prefer-promise-reject-errors
+                });
+            }
+        };
+        // Handle empty array
+        if (items.length === 0) {
+            resolve();
+            return;
+        }
+        run_next();
+    });
+};
 /**
  * Maps over items with controlled concurrency, preserving input order.
  *
@@ -43,7 +105,6 @@ export const map_concurrent = async (items, fn, concurrency) => {
     let next_index = 0;
     let active_count = 0;
     let rejected = false;
-    let reject_error;
     return new Promise((resolve, reject) => {
         const run_next = () => {
             // Stop spawning if we've rejected
@@ -71,8 +132,7 @@ export const map_concurrent = async (items, fn, concurrency) => {
                     if (rejected)
                         return;
                     rejected = true;
-                    reject_error = error;
-                    reject(reject_error); // eslint-disable-line @typescript-eslint/prefer-promise-reject-errors
+                    reject(error); // eslint-disable-line @typescript-eslint/prefer-promise-reject-errors
                 });
             }
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fuzdev/fuz_util",
-  "version": "0.45.2",
+  "version": "0.45.3",
   "description": "utility belt for JS",
   "glyph": "🦕",
   "logo": "logo.svg",

package/src/lib/async.ts

@@ -34,6 +34,77 @@ export const create_deferred = <T>(): Deferred<T> => {
 	return {promise, resolve, reject};
 };
 
+/**
+ * Runs an async function on each item with controlled concurrency.
+ * Like `map_concurrent` but doesn't collect results (more efficient for side effects).
+ *
+ * @param items array of items to process
+ * @param fn async function to apply to each item
+ * @param concurrency maximum number of concurrent operations
+ *
+ * @example
+ * ```ts
+ * await each_concurrent(
+ *   file_paths,
+ *   async (path) => { await unlink(path); },
+ *   5, // max 5 concurrent deletions
+ * );
+ * ```
+ */
+export const each_concurrent = async <T>(
+	items: Array<T>,
+	fn: (item: T, index: number) => Promise<void>,
+	concurrency: number,
+): Promise<void> => {
+	if (concurrency < 1) {
+		throw new Error('concurrency must be at least 1');
+	}
+
+	let next_index = 0;
+	let active_count = 0;
+	let rejected = false;
+
+	return new Promise((resolve, reject) => {
+		const run_next = (): void => {
+			// Stop spawning if we've rejected
+			if (rejected) return;
+
+			// Check if we're done
+			if (next_index >= items.length && active_count === 0) {
+				resolve();
+				return;
+			}
+
+			// Spawn workers up to concurrency limit
+			while (active_count < concurrency && next_index < items.length) {
+				const index = next_index++;
+				const item = items[index]!;
+				active_count++;
+
+				fn(item, index)
+					.then(() => {
+						if (rejected) return;
+						active_count--;
+						run_next();
+					})
+					.catch((error) => {
+						if (rejected) return;
+						rejected = true;
+						reject(error); // eslint-disable-line @typescript-eslint/prefer-promise-reject-errors
+					});
+			}
+		};
+
+		// Handle empty array
+		if (items.length === 0) {
+			resolve();
+			return;
+		}
+
+		run_next();
+	});
+};
+
 /**
  * Maps over items with controlled concurrency, preserving input order.
  *
@@ -64,7 +135,6 @@ export const map_concurrent = async <T, R>(
 	let next_index = 0;
 	let active_count = 0;
 	let rejected = false;
-	let reject_error: unknown;
 
 	return new Promise((resolve, reject) => {
 		const run_next = (): void => {
@@ -93,8 +163,7 @@ export const map_concurrent = async <T, R>(
 					.catch((error) => {
 						if (rejected) return;
 						rejected = true;
-						reject_error = error;
-						reject(reject_error); // eslint-disable-line @typescript-eslint/prefer-promise-reject-errors
+						reject(error); // eslint-disable-line @typescript-eslint/prefer-promise-reject-errors
 					});
 			}
 		};