es-toolkit 1.41.0-dev.1667 → 1.41.0-dev.1669

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

package/dist/array/mapAsync.js

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

package/dist/array/mapAsync.mjs

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

package/dist/array/reduceAsync.d.mts

@@ -0,0 +1,71 @@
+/**
+ * Reduces an array to a single value using an async reducer function.
+ *
+ * Applies the reducer function sequentially to each element (left to right),
+ * carrying an accumulated result from one call to the next. Unlike other async
+ * array methods, reduce must process elements sequentially and does not support
+ * concurrency limiting.
+ *
+ * @template T - The type of elements in the array.
+ * @template U - The type of the accumulated result.
+ * @param {readonly T[]} array The array to reduce.
+ * @param {(accumulator: U, currentValue: T, currentIndex: number, array: readonly T[]) => Promise<U>} reducer An async function that processes each element.
+ * @param {U} initialValue The initial value of the accumulator.
+ * @returns {Promise<U>} A promise that resolves to the final accumulated value.
+ * @example
+ * const numbers = [1, 2, 3, 4, 5];
+ * const sum = await reduceAsync(
+ *   numbers,
+ *   async (acc, n) => acc + await fetchValue(n),
+ *   0
+ * );
+ * // Returns: sum of all fetched values
+ *
+ * @example
+ * const users = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const userMap = await reduceAsync(
+ *   users,
+ *   async (acc, user) => {
+ *     const details = await fetchUserDetails(user.id);
+ *     acc[user.id] = details;
+ *     return acc;
+ *   },
+ *   {} as Record<number, any>
+ * );
+ * // Returns: { 1: {...}, 2: {...}, 3: {...} }
+ */
+declare function reduceAsync<T, U>(array: readonly T[], reducer: (accumulator: U, currentValue: T, currentIndex: number, array: readonly T[]) => Promise<U>, initialValue: U): Promise<U>;
+/**
+ * Reduces an array to a single value using an async reducer function.
+ *
+ * Applies the reducer function sequentially to each element (left to right),
+ * carrying an accumulated result from one call to the next. Unlike other async
+ * array methods, reduce must process elements sequentially and does not support
+ * concurrency limiting.
+ *
+ * When no initial value is provided, the first element of the array is used as
+ * the initial value and the reduction starts from the second element.
+ *
+ * @template T - The type of elements in the array.
+ * @param {readonly T[]} array The array to reduce.
+ * @param {(accumulator: T, currentValue: T, currentIndex: number, array: readonly T[]) => Promise<T>} reducer An async function that processes each element.
+ * @returns {Promise<T | undefined>} A promise that resolves to the final accumulated value, or undefined if the array is empty.
+ * @example
+ * const numbers = [1, 2, 3, 4, 5];
+ * const sum = await reduceAsync(
+ *   numbers,
+ *   async (acc, n) => acc + n
+ * );
+ * // Returns: 15
+ *
+ * @example
+ * const emptyArray: number[] = [];
+ * const result = await reduceAsync(
+ *   emptyArray,
+ *   async (acc, n) => acc + n
+ * );
+ * // Returns: undefined
+ */
+declare function reduceAsync<T>(array: readonly T[], reducer: (accumulator: T, currentValue: T, currentIndex: number, array: readonly T[]) => Promise<T>): Promise<T>;
+
+export { reduceAsync };

package/dist/array/reduceAsync.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Reduces an array to a single value using an async reducer function.
+ *
+ * Applies the reducer function sequentially to each element (left to right),
+ * carrying an accumulated result from one call to the next. Unlike other async
+ * array methods, reduce must process elements sequentially and does not support
+ * concurrency limiting.
+ *
+ * @template T - The type of elements in the array.
+ * @template U - The type of the accumulated result.
+ * @param {readonly T[]} array The array to reduce.
+ * @param {(accumulator: U, currentValue: T, currentIndex: number, array: readonly T[]) => Promise<U>} reducer An async function that processes each element.
+ * @param {U} initialValue The initial value of the accumulator.
+ * @returns {Promise<U>} A promise that resolves to the final accumulated value.
+ * @example
+ * const numbers = [1, 2, 3, 4, 5];
+ * const sum = await reduceAsync(
+ *   numbers,
+ *   async (acc, n) => acc + await fetchValue(n),
+ *   0
+ * );
+ * // Returns: sum of all fetched values
+ *
+ * @example
+ * const users = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const userMap = await reduceAsync(
+ *   users,
+ *   async (acc, user) => {
+ *     const details = await fetchUserDetails(user.id);
+ *     acc[user.id] = details;
+ *     return acc;
+ *   },
+ *   {} as Record<number, any>
+ * );
+ * // Returns: { 1: {...}, 2: {...}, 3: {...} }
+ */
+declare function reduceAsync<T, U>(array: readonly T[], reducer: (accumulator: U, currentValue: T, currentIndex: number, array: readonly T[]) => Promise<U>, initialValue: U): Promise<U>;
+/**
+ * Reduces an array to a single value using an async reducer function.
+ *
+ * Applies the reducer function sequentially to each element (left to right),
+ * carrying an accumulated result from one call to the next. Unlike other async
+ * array methods, reduce must process elements sequentially and does not support
+ * concurrency limiting.
+ *
+ * When no initial value is provided, the first element of the array is used as
+ * the initial value and the reduction starts from the second element.
+ *
+ * @template T - The type of elements in the array.
+ * @param {readonly T[]} array The array to reduce.
+ * @param {(accumulator: T, currentValue: T, currentIndex: number, array: readonly T[]) => Promise<T>} reducer An async function that processes each element.
+ * @returns {Promise<T | undefined>} A promise that resolves to the final accumulated value, or undefined if the array is empty.
+ * @example
+ * const numbers = [1, 2, 3, 4, 5];
+ * const sum = await reduceAsync(
+ *   numbers,
+ *   async (acc, n) => acc + n
+ * );
+ * // Returns: 15
+ *
+ * @example
+ * const emptyArray: number[] = [];
+ * const result = await reduceAsync(
+ *   emptyArray,
+ *   async (acc, n) => acc + n
+ * );
+ * // Returns: undefined
+ */
+declare function reduceAsync<T>(array: readonly T[], reducer: (accumulator: T, currentValue: T, currentIndex: number, array: readonly T[]) => Promise<T>): Promise<T>;
+
+export { reduceAsync };

package/dist/array/reduceAsync.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+async function reduceAsync(array, reducer, initialValue) {
+    let startIndex = 0;
+    if (initialValue == null) {
+        initialValue = array[0];
+        startIndex = 1;
+    }
+    let accumulator = initialValue;
+    for (let i = startIndex; i < array.length; i++) {
+        accumulator = await reducer(accumulator, array[i], i, array);
+    }
+    return accumulator;
+}
+
+exports.reduceAsync = reduceAsync;

package/dist/array/reduceAsync.mjs

@@ -0,0 +1,14 @@
+async function reduceAsync(array, reducer, initialValue) {
+    let startIndex = 0;
+    if (initialValue == null) {
+        initialValue = array[0];
+        startIndex = 1;
+    }
+    let accumulator = initialValue;
+    for (let i = startIndex; i < array.length; i++) {
+        accumulator = await reducer(accumulator, array[i], i, array);
+    }
+    return accumulator;
+}
+
+export { reduceAsync };

package/dist/index.d.mts

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

package/dist/index.d.ts

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

package/dist/index.js

@@ -14,10 +14,13 @@ const dropRight = require('./array/dropRight.js');
 const dropRightWhile = require('./array/dropRightWhile.js');
 const dropWhile = require('./array/dropWhile.js');
 const fill = require('./array/fill.js');
+const filterAsync = require('./array/filterAsync.js');
 const flatMap = require('./array/flatMap.js');
+const flatMapAsync = require('./array/flatMapAsync.js');
 const flatMapDeep = require('./array/flatMapDeep.js');
 const flatten = require('./array/flatten.js');
 const flattenDeep = require('./array/flattenDeep.js');
+const forEachAsync = require('./array/forEachAsync.js');
 const forEachRight = require('./array/forEachRight.js');
 const groupBy = require('./array/groupBy.js');
 const head = require('./array/head.js');
@@ -29,12 +32,15 @@ const isSubset = require('./array/isSubset.js');
 const isSubsetWith = require('./array/isSubsetWith.js');
 const keyBy = require('./array/keyBy.js');
 const last = require('./array/last.js');
+const limitAsync = require('./array/limitAsync.js');
+const mapAsync = require('./array/mapAsync.js');
 const maxBy = require('./array/maxBy.js');
 const minBy = require('./array/minBy.js');
 const orderBy = require('./array/orderBy.js');
 const partition = require('./array/partition.js');
 const pull = require('./array/pull.js');
 const pullAt = require('./array/pullAt.js');
+const reduceAsync = require('./array/reduceAsync.js');
 const remove = require('./array/remove.js');
 const sample = require('./array/sample.js');
 const sampleSize = require('./array/sampleSize.js');
@@ -189,10 +195,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;
@@ -204,12 +213,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/index.mjs

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

package/dist/object/mergeWith.js

@@ -20,7 +20,7 @@ function mergeWith(target, source, merge) {
         }
         else if (Array.isArray(sourceValue)) {
             if (Array.isArray(targetValue)) {
-                target[key] = mergeWith(targetValue ?? [], sourceValue, merge);
+                target[key] = mergeWith(targetValue, sourceValue, merge);
             }
             else {
                 target[key] = mergeWith([], sourceValue, merge);

package/dist/object/mergeWith.mjs

@@ -16,7 +16,7 @@ function mergeWith(target, source, merge) {
         }
         else if (Array.isArray(sourceValue)) {
             if (Array.isArray(targetValue)) {
-                target[key] = mergeWith(targetValue ?? [], sourceValue, merge);
+                target[key] = mergeWith(targetValue, sourceValue, merge);
             }
             else {
                 target[key] = mergeWith([], sourceValue, merge);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "es-toolkit",
-  "version": "1.41.0-dev.1667+8beb7a3f",
+  "version": "1.41.0-dev.1669+506695c9",
   "description": "A state-of-the-art, high-performance JavaScript utility library with a small bundle size and strong type annotations.",
   "homepage": "https://es-toolkit.dev",
   "bugs": "https://github.com/toss/es-toolkit/issues",