es-toolkit 1.41.0 → 1.42.0-dev.1675

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # es-toolkit Changelog
 
+## Version v1.42.0
+
+Released on November 17th, 2025.
+
+- Added new async utilities: `filterAsync`, `flatMapAsync`, `forEachAsync`, `mapAsync`, `reduceAsync`, and `limitAsync` for handling asynchronous operations.
+- Exported `ThrottleOptions` and `DebounceOptions` interfaces for better type support.
+- Fixed `isFinite` to implement type predicate to narrow type to number.
+- Fixed `isSafeInteger` to implement type predicate to narrow type to number.
+- Fixed `omit` to prevent adding index properties to array-like objects.
+- Fixed `mergeWith` to remove unnecessary nullish coalescing for 100% branch coverage.
+- Fixed `compat/updateWith` to remove unreachable code and add prototype pollution test.
+- Updated documentation headings for consistency.
+- Improved test coverage for `compat/mergeWith`, `compat/unset`, `get`, `toMerged`, `mergeWith`, and `compat/intersectionBy` with additional edge cases and security tests.
+
+We sincerely thank @Debbl, @wo-o29, @raon0211, @Yeom-JinHo, @sukvvon, and @D-Sketon for their contributions. We appreciate your great efforts!
+
 ## Version v1.41.0
 
 Released on October 24th, 2025.

package/dist/array/filterAsync.d.mts

@@ -0,0 +1,35 @@
+interface FilterAsyncOptions {
+    concurrency?: number;
+}
+/**
+ * Filters an array asynchronously using an async predicate function.
+ *
+ * Returns a promise that resolves to a new array containing only the elements
+ * for which the predicate function returns a truthy value.
+ *
+ * @template T - The type of elements in the array.
+ * @param {readonly T[]} array The array to filter.
+ * @param {(item: T, index: number, array: readonly T[]) => Promise<boolean>} predicate An async function that tests each element.
+ * @param {FilterAsyncOptions} [options] Optional configuration object.
+ * @param {number} [options.concurrency] Maximum number of concurrent async operations. If not specified, all operations run concurrently.
+ * @returns {Promise<T[]>} A promise that resolves to the filtered array.
+ * @example
+ * const users = [{ id: 1, active: true }, { id: 2, active: false }, { id: 3, active: true }];
+ * const activeUsers = await filterAsync(users, async (user) => {
+ *   return await checkUserStatus(user.id);
+ * });
+ * // Returns: [{ id: 1, active: true }, { id: 3, active: true }]
+ *
+ * @example
+ * // With concurrency limit
+ * const numbers = [1, 2, 3, 4, 5];
+ * const evenNumbers = await filterAsync(
+ *   numbers,
+ *   async (n) => await isEvenAsync(n),
+ *   { concurrency: 2 }
+ * );
+ * // Processes at most 2 operations concurrently
+ */
+declare function filterAsync<T>(array: readonly T[], predicate: (item: T, index: number, array: readonly T[]) => Promise<boolean>, options?: FilterAsyncOptions): Promise<T[]>;
+
+export { filterAsync };

package/dist/array/filterAsync.d.ts

@@ -0,0 +1,35 @@
+interface FilterAsyncOptions {
+    concurrency?: number;
+}
+/**
+ * Filters an array asynchronously using an async predicate function.
+ *
+ * Returns a promise that resolves to a new array containing only the elements
+ * for which the predicate function returns a truthy value.
+ *
+ * @template T - The type of elements in the array.
+ * @param {readonly T[]} array The array to filter.
+ * @param {(item: T, index: number, array: readonly T[]) => Promise<boolean>} predicate An async function that tests each element.
+ * @param {FilterAsyncOptions} [options] Optional configuration object.
+ * @param {number} [options.concurrency] Maximum number of concurrent async operations. If not specified, all operations run concurrently.
+ * @returns {Promise<T[]>} A promise that resolves to the filtered array.
+ * @example
+ * const users = [{ id: 1, active: true }, { id: 2, active: false }, { id: 3, active: true }];
+ * const activeUsers = await filterAsync(users, async (user) => {
+ *   return await checkUserStatus(user.id);
+ * });
+ * // Returns: [{ id: 1, active: true }, { id: 3, active: true }]
+ *
+ * @example
+ * // With concurrency limit
+ * const numbers = [1, 2, 3, 4, 5];
+ * const evenNumbers = await filterAsync(
+ *   numbers,
+ *   async (n) => await isEvenAsync(n),
+ *   { concurrency: 2 }
+ * );
+ * // Processes at most 2 operations concurrently
+ */
+declare function filterAsync<T>(array: readonly T[], predicate: (item: T, index: number, array: readonly T[]) => Promise<boolean>, options?: FilterAsyncOptions): Promise<T[]>;
+
+export { filterAsync };

package/dist/array/filterAsync.js

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const limitAsync = require('./limitAsync.js');
+
+async function filterAsync(array, predicate, options) {
+    if (options?.concurrency != null) {
+        predicate = limitAsync.limitAsync(predicate, options.concurrency);
+    }
+    const results = await Promise.all(array.map(predicate));
+    return array.filter((_, index) => results[index]);
+}
+
+exports.filterAsync = filterAsync;

package/dist/array/filterAsync.mjs

@@ -0,0 +1,11 @@
+import { limitAsync } from './limitAsync.mjs';
+
+async function filterAsync(array, predicate, options) {
+    if (options?.concurrency != null) {
+        predicate = limitAsync(predicate, options.concurrency);
+    }
+    const results = await Promise.all(array.map(predicate));
+    return array.filter((_, index) => results[index]);
+}
+
+export { filterAsync };

package/dist/array/flatMapAsync.d.mts

@@ -0,0 +1,37 @@
+interface FlatMapAsyncOptions {
+    concurrency?: number;
+}
+/**
+ * Maps each element in an array using an async callback function and flattens the result by one level.
+ *
+ * This is equivalent to calling `mapAsync` followed by `flat(1)`, but more efficient.
+ * Each callback should return an array, and all returned arrays are concatenated into
+ * a single output array.
+ *
+ * @template T - The type of elements in the input array.
+ * @template R - The type of elements in the arrays returned by the callback.
+ * @param {readonly T[]} array The array to transform.
+ * @param {(item: T, index: number, array: readonly T[]) => Promise<R[]>} callback An async function that transforms each element into an array.
+ * @param {FlatMapAsyncOptions} [options] Optional configuration object.
+ * @param {number} [options.concurrency] Maximum number of concurrent async operations. If not specified, all operations run concurrently.
+ * @returns {Promise<R[]>} A promise that resolves to a flattened array of transformed values.
+ * @example
+ * const users = [{ id: 1 }, { id: 2 }];
+ * const allPosts = await flatMapAsync(users, async (user) => {
+ *   return await fetchUserPosts(user.id);
+ * });
+ * // Returns: [post1, post2, post3, ...] (all posts from all users)
+ *
+ * @example
+ * // With concurrency limit
+ * const numbers = [1, 2, 3];
+ * const results = await flatMapAsync(
+ *   numbers,
+ *   async (n) => await fetchRelatedItems(n),
+ *   { concurrency: 2 }
+ * );
+ * // Processes at most 2 operations concurrently
+ */
+declare function flatMapAsync<T, R>(array: readonly T[], callback: (item: T, index: number, array: readonly T[]) => Promise<R[]>, options?: FlatMapAsyncOptions): Promise<R[]>;
+
+export { flatMapAsync };

package/dist/array/flatMapAsync.d.ts

@@ -0,0 +1,37 @@
+interface FlatMapAsyncOptions {
+    concurrency?: number;
+}
+/**
+ * Maps each element in an array using an async callback function and flattens the result by one level.
+ *
+ * This is equivalent to calling `mapAsync` followed by `flat(1)`, but more efficient.
+ * Each callback should return an array, and all returned arrays are concatenated into
+ * a single output array.
+ *
+ * @template T - The type of elements in the input array.
+ * @template R - The type of elements in the arrays returned by the callback.
+ * @param {readonly T[]} array The array to transform.
+ * @param {(item: T, index: number, array: readonly T[]) => Promise<R[]>} callback An async function that transforms each element into an array.
+ * @param {FlatMapAsyncOptions} [options] Optional configuration object.
+ * @param {number} [options.concurrency] Maximum number of concurrent async operations. If not specified, all operations run concurrently.
+ * @returns {Promise<R[]>} A promise that resolves to a flattened array of transformed values.
+ * @example
+ * const users = [{ id: 1 }, { id: 2 }];
+ * const allPosts = await flatMapAsync(users, async (user) => {
+ *   return await fetchUserPosts(user.id);
+ * });
+ * // Returns: [post1, post2, post3, ...] (all posts from all users)
+ *
+ * @example
+ * // With concurrency limit
+ * const numbers = [1, 2, 3];
+ * const results = await flatMapAsync(
+ *   numbers,
+ *   async (n) => await fetchRelatedItems(n),
+ *   { concurrency: 2 }
+ * );
+ * // Processes at most 2 operations concurrently
+ */
+declare function flatMapAsync<T, R>(array: readonly T[], callback: (item: T, index: number, array: readonly T[]) => Promise<R[]>, options?: FlatMapAsyncOptions): Promise<R[]>;
+
+export { flatMapAsync };

package/dist/array/flatMapAsync.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const flatten = require('./flatten.js');
+const limitAsync = require('./limitAsync.js');
+
+async function flatMapAsync(array, callback, options) {
+    if (options?.concurrency != null) {
+        callback = limitAsync.limitAsync(callback, options.concurrency);
+    }
+    const results = await Promise.all(array.map(callback));
+    return flatten.flatten(results);
+}
+
+exports.flatMapAsync = flatMapAsync;

package/dist/array/flatMapAsync.mjs

@@ -0,0 +1,12 @@
+import { flatten } from './flatten.mjs';
+import { limitAsync } from './limitAsync.mjs';
+
+async function flatMapAsync(array, callback, options) {
+    if (options?.concurrency != null) {
+        callback = limitAsync(callback, options.concurrency);
+    }
+    const results = await Promise.all(array.map(callback));
+    return flatten(results);
+}
+
+export { flatMapAsync };

package/dist/array/forEachAsync.d.mts

@@ -0,0 +1,35 @@
+interface ForEachAsyncOptions {
+    concurrency?: number;
+}
+/**
+ * Executes an async callback function for each element in an array.
+ *
+ * Unlike the native `forEach`, this function returns a promise that resolves
+ * when all async operations complete. It supports optional concurrency limiting.
+ *
+ * @template T - The type of elements in the array.
+ * @param {readonly T[]} array The array to iterate over.
+ * @param {(item: T, index: number, array: readonly T[]) => Promise<void>} callback An async function to execute for each element.
+ * @param {ForEachAsyncOptions} [options] Optional configuration object.
+ * @param {number} [options.concurrency] Maximum number of concurrent async operations. If not specified, all operations run concurrently.
+ * @returns {Promise<void>} A promise that resolves when all operations complete.
+ * @example
+ * const users = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * await forEachAsync(users, async (user) => {
+ *   await updateUser(user.id);
+ * });
+ * // All users have been updated
+ *
+ * @example
+ * // With concurrency limit
+ * const items = [1, 2, 3, 4, 5];
+ * await forEachAsync(
+ *   items,
+ *   async (item) => await processItem(item),
+ *   { concurrency: 2 }
+ * );
+ * // Processes at most 2 items concurrently
+ */
+declare function forEachAsync<T>(array: readonly T[], callback: (item: T, index: number, array: readonly T[]) => Promise<void>, options?: ForEachAsyncOptions): Promise<void>;
+
+export { forEachAsync };

package/dist/array/forEachAsync.d.ts

@@ -0,0 +1,35 @@
+interface ForEachAsyncOptions {
+    concurrency?: number;
+}
+/**
+ * Executes an async callback function for each element in an array.
+ *
+ * Unlike the native `forEach`, this function returns a promise that resolves
+ * when all async operations complete. It supports optional concurrency limiting.
+ *
+ * @template T - The type of elements in the array.
+ * @param {readonly T[]} array The array to iterate over.
+ * @param {(item: T, index: number, array: readonly T[]) => Promise<void>} callback An async function to execute for each element.
+ * @param {ForEachAsyncOptions} [options] Optional configuration object.
+ * @param {number} [options.concurrency] Maximum number of concurrent async operations. If not specified, all operations run concurrently.
+ * @returns {Promise<void>} A promise that resolves when all operations complete.
+ * @example
+ * const users = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * await forEachAsync(users, async (user) => {
+ *   await updateUser(user.id);
+ * });
+ * // All users have been updated
+ *
+ * @example
+ * // With concurrency limit
+ * const items = [1, 2, 3, 4, 5];
+ * await forEachAsync(
+ *   items,
+ *   async (item) => await processItem(item),
+ *   { concurrency: 2 }
+ * );
+ * // Processes at most 2 items concurrently
+ */
+declare function forEachAsync<T>(array: readonly T[], callback: (item: T, index: number, array: readonly T[]) => Promise<void>, options?: ForEachAsyncOptions): Promise<void>;
+
+export { forEachAsync };

package/dist/array/forEachAsync.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const limitAsync = require('./limitAsync.js');
+
+async function forEachAsync(array, callback, options) {
+    if (options?.concurrency != null) {
+        callback = limitAsync.limitAsync(callback, options.concurrency);
+    }
+    await Promise.all(array.map(callback));
+}
+
+exports.forEachAsync = forEachAsync;

package/dist/array/forEachAsync.mjs

@@ -0,0 +1,10 @@
+import { limitAsync } from './limitAsync.mjs';
+
+async function forEachAsync(array, callback, options) {
+    if (options?.concurrency != null) {
+        callback = limitAsync(callback, options.concurrency);
+    }
+    await Promise.all(array.map(callback));
+}
+
+export { forEachAsync };

package/dist/array/index.d.mts

@@ -10,10 +10,13 @@ export { dropRight } from './dropRight.mjs';
 export { dropRightWhile } from './dropRightWhile.mjs';
 export { dropWhile } from './dropWhile.mjs';
 export { fill } from './fill.mjs';
+export { filterAsync } from './filterAsync.mjs';
 export { flatMap } from './flatMap.mjs';
+export { flatMapAsync } from './flatMapAsync.mjs';
 export { flatMapDeep } from './flatMapDeep.mjs';
 export { flatten } from './flatten.mjs';
 export { flattenDeep } from './flattenDeep.mjs';
+export { forEachAsync } from './forEachAsync.mjs';
 export { forEachRight } from './forEachRight.mjs';
 export { groupBy } from './groupBy.mjs';
 export { head } from './head.mjs';
@@ -25,12 +28,15 @@ export { isSubset } from './isSubset.mjs';
 export { isSubsetWith } from './isSubsetWith.mjs';
 export { keyBy } from './keyBy.mjs';
 export { last } from './last.mjs';
+export { limitAsync } from './limitAsync.mjs';
+export { mapAsync } from './mapAsync.mjs';
 export { maxBy } from './maxBy.mjs';
 export { minBy } from './minBy.mjs';
 export { orderBy } from './orderBy.mjs';
 export { partition } from './partition.mjs';
 export { pull } from './pull.mjs';
 export { pullAt } from './pullAt.mjs';
+export { reduceAsync } from './reduceAsync.mjs';
 export { remove } from './remove.mjs';
 export { sample } from './sample.mjs';
 export { sampleSize } from './sampleSize.mjs';

package/dist/array/index.d.ts

@@ -10,10 +10,13 @@ export { dropRight } from './dropRight.js';
 export { dropRightWhile } from './dropRightWhile.js';
 export { dropWhile } from './dropWhile.js';
 export { fill } from './fill.js';
+export { filterAsync } from './filterAsync.js';
 export { flatMap } from './flatMap.js';
+export { flatMapAsync } from './flatMapAsync.js';
 export { flatMapDeep } from './flatMapDeep.js';
 export { flatten } from './flatten.js';
 export { flattenDeep } from './flattenDeep.js';
+export { forEachAsync } from './forEachAsync.js';
 export { forEachRight } from './forEachRight.js';
 export { groupBy } from './groupBy.js';
 export { head } from './head.js';
@@ -25,12 +28,15 @@ export { isSubset } from './isSubset.js';
 export { isSubsetWith } from './isSubsetWith.js';
 export { keyBy } from './keyBy.js';
 export { last } from './last.js';
+export { limitAsync } from './limitAsync.js';
+export { mapAsync } from './mapAsync.js';
 export { maxBy } from './maxBy.js';
 export { minBy } from './minBy.js';
 export { orderBy } from './orderBy.js';
 export { partition } from './partition.js';
 export { pull } from './pull.js';
 export { pullAt } from './pullAt.js';
+export { reduceAsync } from './reduceAsync.js';
 export { remove } from './remove.js';
 export { sample } from './sample.js';
 export { sampleSize } from './sampleSize.js';

package/dist/array/index.js

@@ -14,10 +14,13 @@ const dropRight = require('./dropRight.js');
 const dropRightWhile = require('./dropRightWhile.js');
 const dropWhile = require('./dropWhile.js');
 const fill = require('./fill.js');
+const filterAsync = require('./filterAsync.js');
 const flatMap = require('./flatMap.js');
+const flatMapAsync = require('./flatMapAsync.js');
 const flatMapDeep = require('./flatMapDeep.js');
 const flatten = require('./flatten.js');
 const flattenDeep = require('./flattenDeep.js');
+const forEachAsync = require('./forEachAsync.js');
 const forEachRight = require('./forEachRight.js');
 const groupBy = require('./groupBy.js');
 const head = require('./head.js');
@@ -29,12 +32,15 @@ const isSubset = require('./isSubset.js');
 const isSubsetWith = require('./isSubsetWith.js');
 const keyBy = require('./keyBy.js');
 const last = require('./last.js');
+const limitAsync = require('./limitAsync.js');
+const mapAsync = require('./mapAsync.js');
 const maxBy = require('./maxBy.js');
 const minBy = require('./minBy.js');
 const orderBy = require('./orderBy.js');
 const partition = require('./partition.js');
 const pull = require('./pull.js');
 const pullAt = require('./pullAt.js');
+const reduceAsync = require('./reduceAsync.js');
 const remove = require('./remove.js');
 const sample = require('./sample.js');
 const sampleSize = require('./sampleSize.js');
@@ -77,10 +83,13 @@ exports.dropRight = dropRight.dropRight;
 exports.dropRightWhile = dropRightWhile.dropRightWhile;
 exports.dropWhile = dropWhile.dropWhile;
 exports.fill = fill.fill;
+exports.filterAsync = filterAsync.filterAsync;
 exports.flatMap = flatMap.flatMap;
+exports.flatMapAsync = flatMapAsync.flatMapAsync;
 exports.flatMapDeep = flatMapDeep.flatMapDeep;
 exports.flatten = flatten.flatten;
 exports.flattenDeep = flattenDeep.flattenDeep;
+exports.forEachAsync = forEachAsync.forEachAsync;
 exports.forEachRight = forEachRight.forEachRight;
 exports.groupBy = groupBy.groupBy;
 exports.head = head.head;
@@ -92,12 +101,15 @@ exports.isSubset = isSubset.isSubset;
 exports.isSubsetWith = isSubsetWith.isSubsetWith;
 exports.keyBy = keyBy.keyBy;
 exports.last = last.last;
+exports.limitAsync = limitAsync.limitAsync;
+exports.mapAsync = mapAsync.mapAsync;
 exports.maxBy = maxBy.maxBy;
 exports.minBy = minBy.minBy;
 exports.orderBy = orderBy.orderBy;
 exports.partition = partition.partition;
 exports.pull = pull.pull;
 exports.pullAt = pullAt.pullAt;
+exports.reduceAsync = reduceAsync.reduceAsync;
 exports.remove = remove.remove;
 exports.sample = sample.sample;
 exports.sampleSize = sampleSize.sampleSize;

package/dist/array/index.mjs

@@ -10,10 +10,13 @@ export { dropRight } from './dropRight.mjs';
 export { dropRightWhile } from './dropRightWhile.mjs';
 export { dropWhile } from './dropWhile.mjs';
 export { fill } from './fill.mjs';
+export { filterAsync } from './filterAsync.mjs';
 export { flatMap } from './flatMap.mjs';
+export { flatMapAsync } from './flatMapAsync.mjs';
 export { flatMapDeep } from './flatMapDeep.mjs';
 export { flatten } from './flatten.mjs';
 export { flattenDeep } from './flattenDeep.mjs';
+export { forEachAsync } from './forEachAsync.mjs';
 export { forEachRight } from './forEachRight.mjs';
 export { groupBy } from './groupBy.mjs';
 export { head } from './head.mjs';
@@ -25,12 +28,15 @@ export { isSubset } from './isSubset.mjs';
 export { isSubsetWith } from './isSubsetWith.mjs';
 export { keyBy } from './keyBy.mjs';
 export { last } from './last.mjs';
+export { limitAsync } from './limitAsync.mjs';
+export { mapAsync } from './mapAsync.mjs';
 export { maxBy } from './maxBy.mjs';
 export { minBy } from './minBy.mjs';
 export { orderBy } from './orderBy.mjs';
 export { partition } from './partition.mjs';
 export { pull } from './pull.mjs';
 export { pullAt } from './pullAt.mjs';
+export { reduceAsync } from './reduceAsync.mjs';
 export { remove } from './remove.mjs';
 export { sample } from './sample.mjs';
 export { sampleSize } from './sampleSize.mjs';

package/dist/array/limitAsync.d.mts

@@ -0,0 +1,34 @@
+/**
+ * Wraps an async function to limit the number of concurrent executions.
+ *
+ * This function creates a wrapper around an async callback that ensures at most
+ * `concurrency` number of executions can run simultaneously. Additional calls will
+ * wait until a slot becomes available.
+ *
+ * @template F - The type of the async function to wrap.
+ * @param {F} callback The async function to wrap with concurrency control.
+ * @param {number} concurrency Maximum number of concurrent executions allowed.
+ * @returns {F} A wrapped version of the callback with concurrency limiting.
+ * @example
+ * const limitedFetch = limitAsync(async (url) => {
+ *   return await fetch(url);
+ * }, 3);
+ *
+ * // Only 3 fetches will run concurrently
+ * const urls = ['url1', 'url2', 'url3', 'url4', 'url5'];
+ * await Promise.all(urls.map(url => limitedFetch(url)));
+ *
+ * @example
+ * const processItem = async (item) => {
+ *   // Expensive async operation
+ *   return await heavyComputation(item);
+ * };
+ *
+ * const limitedProcess = limitAsync(processItem, 2);
+ * const items = [1, 2, 3, 4, 5];
+ * // At most 2 items will be processed concurrently
+ * await Promise.all(items.map(item => limitedProcess(item)));
+ */
+declare function limitAsync<F extends (...args: any[]) => Promise<any>>(callback: F, concurrency: number): F;
+
+export { limitAsync };

package/dist/array/limitAsync.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Wraps an async function to limit the number of concurrent executions.
+ *
+ * This function creates a wrapper around an async callback that ensures at most
+ * `concurrency` number of executions can run simultaneously. Additional calls will
+ * wait until a slot becomes available.
+ *
+ * @template F - The type of the async function to wrap.
+ * @param {F} callback The async function to wrap with concurrency control.
+ * @param {number} concurrency Maximum number of concurrent executions allowed.
+ * @returns {F} A wrapped version of the callback with concurrency limiting.
+ * @example
+ * const limitedFetch = limitAsync(async (url) => {
+ *   return await fetch(url);
+ * }, 3);
+ *
+ * // Only 3 fetches will run concurrently
+ * const urls = ['url1', 'url2', 'url3', 'url4', 'url5'];
+ * await Promise.all(urls.map(url => limitedFetch(url)));
+ *
+ * @example
+ * const processItem = async (item) => {
+ *   // Expensive async operation
+ *   return await heavyComputation(item);
+ * };
+ *
+ * const limitedProcess = limitAsync(processItem, 2);
+ * const items = [1, 2, 3, 4, 5];
+ * // At most 2 items will be processed concurrently
+ * await Promise.all(items.map(item => limitedProcess(item)));
+ */
+declare function limitAsync<F extends (...args: any[]) => Promise<any>>(callback: F, concurrency: number): F;
+
+export { limitAsync };

package/dist/array/limitAsync.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const semaphore = require('../promise/semaphore.js');
+
+function limitAsync(callback, concurrency) {
+    const semaphore$1 = new semaphore.Semaphore(concurrency);
+    return async function (...args) {
+        try {
+            await semaphore$1.acquire();
+            return await callback.apply(this, args);
+        }
+        finally {
+            semaphore$1.release();
+        }
+    };
+}
+
+exports.limitAsync = limitAsync;

package/dist/array/limitAsync.mjs

@@ -0,0 +1,16 @@
+import { Semaphore } from '../promise/semaphore.mjs';
+
+function limitAsync(callback, concurrency) {
+    const semaphore = new Semaphore(concurrency);
+    return async function (...args) {
+        try {
+            await semaphore.acquire();
+            return await callback.apply(this, args);
+        }
+        finally {
+            semaphore.release();
+        }
+    };
+}
+
+export { limitAsync };

package/dist/array/mapAsync.d.mts

@@ -0,0 +1,34 @@
+interface MapAsyncOptions {
+    concurrency?: number;
+}
+/**
+ * Transforms each element in an array using an async callback function and returns
+ * a promise that resolves to an array of transformed values.
+ *
+ * @template T - The type of elements in the input array.
+ * @template R - The type of elements in the output array.
+ * @param {readonly T[]} array The array to transform.
+ * @param {(item: T, index: number, array: readonly T[]) => Promise<R>} callback An async function that transforms each element.
+ * @param {MapAsyncOptions} [options] Optional configuration object.
+ * @param {number} [options.concurrency] Maximum number of concurrent async operations. If not specified, all operations run concurrently.
+ * @returns {Promise<R[]>} A promise that resolves to an array of transformed values.
+ * @example
+ * const users = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const userDetails = await mapAsync(users, async (user) => {
+ *   return await fetchUserDetails(user.id);
+ * });
+ * // Returns: [{ id: 1, name: '...' }, { id: 2, name: '...' }, { id: 3, name: '...' }]
+ *
+ * @example
+ * // With concurrency limit
+ * const numbers = [1, 2, 3, 4, 5];
+ * const results = await mapAsync(
+ *   numbers,
+ *   async (n) => await slowOperation(n),
+ *   { concurrency: 2 }
+ * );
+ * // Processes at most 2 operations concurrently
+ */
+declare function mapAsync<T, R>(array: readonly T[], callback: (item: T, index: number, array: readonly T[]) => Promise<R>, options?: MapAsyncOptions): Promise<R[]>;
+
+export { mapAsync };

package/dist/array/mapAsync.d.ts

@@ -0,0 +1,34 @@
+interface MapAsyncOptions {
+    concurrency?: number;
+}
+/**
+ * Transforms each element in an array using an async callback function and returns
+ * a promise that resolves to an array of transformed values.
+ *
+ * @template T - The type of elements in the input array.
+ * @template R - The type of elements in the output array.
+ * @param {readonly T[]} array The array to transform.
+ * @param {(item: T, index: number, array: readonly T[]) => Promise<R>} callback An async function that transforms each element.
+ * @param {MapAsyncOptions} [options] Optional configuration object.
+ * @param {number} [options.concurrency] Maximum number of concurrent async operations. If not specified, all operations run concurrently.
+ * @returns {Promise<R[]>} A promise that resolves to an array of transformed values.
+ * @example
+ * const users = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const userDetails = await mapAsync(users, async (user) => {
+ *   return await fetchUserDetails(user.id);
+ * });
+ * // Returns: [{ id: 1, name: '...' }, { id: 2, name: '...' }, { id: 3, name: '...' }]
+ *
+ * @example
+ * // With concurrency limit
+ * const numbers = [1, 2, 3, 4, 5];
+ * const results = await mapAsync(
+ *   numbers,
+ *   async (n) => await slowOperation(n),
+ *   { concurrency: 2 }
+ * );
+ * // Processes at most 2 operations concurrently
+ */
+declare function mapAsync<T, R>(array: readonly T[], callback: (item: T, index: number, array: readonly T[]) => Promise<R>, options?: MapAsyncOptions): Promise<R[]>;
+
+export { mapAsync };