es-toolkit 1.50.0-dev.2048 → 1.50.0-dev.2050

package/dist/array/filterAsync.js

@@ -1,4 +1,4 @@
-const require_limitAsync = require("./limitAsync.js");
+const require_limitAsync = require("../promise/limitAsync.js");
 //#region src/array/filterAsync.ts
 /**
 * Filters an array asynchronously using an async predicate function.

package/dist/array/filterAsync.mjs

@@ -1,4 +1,4 @@
-import { limitAsync } from "./limitAsync.mjs";
+import { limitAsync } from "../promise/limitAsync.mjs";
 //#region src/array/filterAsync.ts
 /**
 * Filters an array asynchronously using an async predicate function.

package/dist/array/flatMapAsync.js

@@ -1,4 +1,4 @@
-const require_limitAsync = require("./limitAsync.js");
+const require_limitAsync = require("../promise/limitAsync.js");
 const require_flatten = require("./flatten.js");
 //#region src/array/flatMapAsync.ts
 /**

package/dist/array/flatMapAsync.mjs

@@ -1,4 +1,4 @@
-import { limitAsync } from "./limitAsync.mjs";
+import { limitAsync } from "../promise/limitAsync.mjs";
 import { flatten } from "./flatten.mjs";
 //#region src/array/flatMapAsync.ts
 /**

package/dist/array/forEachAsync.js

@@ -1,4 +1,4 @@
-const require_limitAsync = require("./limitAsync.js");
+const require_limitAsync = require("../promise/limitAsync.js");
 //#region src/array/forEachAsync.ts
 /**
 * Executes an async callback function for each element in an array.

package/dist/array/forEachAsync.mjs

@@ -1,4 +1,4 @@
-import { limitAsync } from "./limitAsync.mjs";
+import { limitAsync } from "../promise/limitAsync.mjs";
 //#region src/array/forEachAsync.ts
 /**
 * Executes an async callback function for each element in an array.

package/dist/array/index.js

@@ -14,7 +14,6 @@ const require_dropRight = require("./dropRight.js");
 const require_dropRightWhile = require("./dropRightWhile.js");
 const require_dropWhile = require("./dropWhile.js");
 const require_fill = require("./fill.js");
-const require_limitAsync = require("./limitAsync.js");
 const require_filterAsync = require("./filterAsync.js");
 const require_flatten = require("./flatten.js");
 const require_flatMap = require("./flatMap.js");
@@ -33,6 +32,7 @@ const require_isSubset = require("./isSubset.js");
 const require_isSubsetWith = require("./isSubsetWith.js");
 const require_keyBy = require("./keyBy.js");
 const require_last = require("./last.js");
+const require_limitAsync = require("./limitAsync.js");
 const require_mapAsync = require("./mapAsync.js");
 const require_maxBy = require("./maxBy.js");
 const require_minBy = require("./minBy.js");

package/dist/array/index.mjs

@@ -13,7 +13,6 @@ import { dropRight } from "./dropRight.mjs";
 import { dropRightWhile } from "./dropRightWhile.mjs";
 import { dropWhile } from "./dropWhile.mjs";
 import { fill } from "./fill.mjs";
-import { limitAsync } from "./limitAsync.mjs";
 import { filterAsync } from "./filterAsync.mjs";
 import { flatten } from "./flatten.mjs";
 import { flatMap } from "./flatMap.mjs";
@@ -32,6 +31,7 @@ import { isSubset } from "./isSubset.mjs";
 import { isSubsetWith } from "./isSubsetWith.mjs";
 import { keyBy } from "./keyBy.mjs";
 import { last } from "./last.mjs";
+import { limitAsync } from "./limitAsync.mjs";
 import { mapAsync } from "./mapAsync.mjs";
 import { maxBy } from "./maxBy.mjs";
 import { minBy } from "./minBy.mjs";

package/dist/array/limitAsync.d.mts

@@ -1,35 +1,11 @@
+import { limitAsync as limitAsync$1 } from "../promise/limitAsync.mjs";
+
 //#region src/array/limitAsync.d.ts
 /**
  * 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 callback The async function to wrap with concurrency control.
- * @param concurrency Maximum number of concurrent executions allowed.
- * @returns 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)));
+ * @deprecated Use `limitAsync` from `es-toolkit/promise` instead. This export will be removed from `es-toolkit/array` in a future major version.
  */
-declare function limitAsync<F extends (...args: any[]) => Promise<any>>(callback: F, concurrency: number): F;
+declare const limitAsync: typeof limitAsync$1;
 //#endregion
 export { limitAsync };

package/dist/array/limitAsync.d.ts

@@ -1,35 +1,11 @@
+import { limitAsync as limitAsync$1 } from "../promise/limitAsync.js";
+
 //#region src/array/limitAsync.d.ts
 /**
  * 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 callback The async function to wrap with concurrency control.
- * @param concurrency Maximum number of concurrent executions allowed.
- * @returns 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)));
+ * @deprecated Use `limitAsync` from `es-toolkit/promise` instead. This export will be removed from `es-toolkit/array` in a future major version.
  */
-declare function limitAsync<F extends (...args: any[]) => Promise<any>>(callback: F, concurrency: number): F;
+declare const limitAsync: typeof limitAsync$1;
 //#endregion
 export { limitAsync };

package/dist/array/limitAsync.js

@@ -1,46 +1,9 @@
-const require_semaphore = require("../promise/semaphore.js");
 //#region src/array/limitAsync.ts
 /**
 * 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 callback The async function to wrap with concurrency control.
-* @param concurrency Maximum number of concurrent executions allowed.
-* @returns 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)));
+* @deprecated Use `limitAsync` from `es-toolkit/promise` instead. This export will be removed from `es-toolkit/array` in a future major version.
 */
-function limitAsync(callback, concurrency) {
-	const semaphore = new require_semaphore.Semaphore(concurrency);
-	return async function(...args) {
-		try {
-			await semaphore.acquire();
-			return await callback.apply(this, args);
-		} finally {
-			semaphore.release();
-		}
-	};
-}
+const limitAsync = require("../promise/limitAsync.js").limitAsync;
 //#endregion
 exports.limitAsync = limitAsync;

package/dist/array/limitAsync.mjs

@@ -1,46 +1,10 @@
-import { Semaphore } from "../promise/semaphore.mjs";
+import { limitAsync as limitAsync$1 } from "../promise/limitAsync.mjs";
 //#region src/array/limitAsync.ts
 /**
 * 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 callback The async function to wrap with concurrency control.
-* @param concurrency Maximum number of concurrent executions allowed.
-* @returns 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)));
+* @deprecated Use `limitAsync` from `es-toolkit/promise` instead. This export will be removed from `es-toolkit/array` in a future major version.
 */
-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();
-		}
-	};
-}
+const limitAsync = limitAsync$1;
 //#endregion
 export { limitAsync };

package/dist/array/mapAsync.js

@@ -1,4 +1,4 @@
-const require_limitAsync = require("./limitAsync.js");
+const require_limitAsync = require("../promise/limitAsync.js");
 //#region src/array/mapAsync.ts
 /**
 * Transforms each element in an array using an async callback function and returns

package/dist/array/mapAsync.mjs

@@ -1,4 +1,4 @@
-import { limitAsync } from "./limitAsync.mjs";
+import { limitAsync } from "../promise/limitAsync.mjs";
 //#region src/array/mapAsync.ts
 /**
 * Transforms each element in an array using an async callback function and returns

package/dist/index.d.mts

@@ -31,7 +31,7 @@ import { isSubset } from "./array/isSubset.mjs";
 import { isSubsetWith } from "./array/isSubsetWith.mjs";
 import { keyBy } from "./array/keyBy.mjs";
 import { last } from "./array/last.mjs";
-import { limitAsync } from "./array/limitAsync.mjs";
+import { limitAsync } from "./promise/limitAsync.mjs";
 import { mapAsync } from "./array/mapAsync.mjs";
 import { maxBy } from "./array/maxBy.mjs";
 import { minBy } from "./array/minBy.mjs";

package/dist/index.d.ts

@@ -31,7 +31,7 @@ import { isSubset } from "./array/isSubset.js";
 import { isSubsetWith } from "./array/isSubsetWith.js";
 import { keyBy } from "./array/keyBy.js";
 import { last } from "./array/last.js";
-import { limitAsync } from "./array/limitAsync.js";
+import { limitAsync } from "./promise/limitAsync.js";
 import { mapAsync } from "./array/mapAsync.js";
 import { maxBy } from "./array/maxBy.js";
 import { minBy } from "./array/minBy.js";

package/dist/index.js

@@ -15,7 +15,7 @@ const require_dropRightWhile = require("./array/dropRightWhile.js");
 const require_dropWhile = require("./array/dropWhile.js");
 const require_fill = require("./array/fill.js");
 const require_semaphore = require("./promise/semaphore.js");
-const require_limitAsync = require("./array/limitAsync.js");
+const require_limitAsync = require("./promise/limitAsync.js");
 const require_filterAsync = require("./array/filterAsync.js");
 const require_flatten = require("./array/flatten.js");
 const require_flatMap = require("./array/flatMap.js");

package/dist/index.mjs

@@ -14,7 +14,7 @@ import { dropRightWhile } from "./array/dropRightWhile.mjs";
 import { dropWhile } from "./array/dropWhile.mjs";
 import { fill } from "./array/fill.mjs";
 import { Semaphore } from "./promise/semaphore.mjs";
-import { limitAsync } from "./array/limitAsync.mjs";
+import { limitAsync } from "./promise/limitAsync.mjs";
 import { filterAsync } from "./array/filterAsync.mjs";
 import { flatten } from "./array/flatten.mjs";
 import { flatMap } from "./array/flatMap.mjs";

package/dist/promise/index.d.mts

@@ -1,7 +1,8 @@
+import { limitAsync } from "./limitAsync.mjs";
 import { allKeyed } from "./allKeyed.mjs";
 import { delay } from "./delay.mjs";
 import { Mutex } from "./mutex.mjs";
 import { Semaphore } from "./semaphore.mjs";
 import { timeout } from "./timeout.mjs";
 import { withTimeout } from "./withTimeout.mjs";
-export { Mutex, Semaphore, allKeyed, delay, timeout, withTimeout };
+export { Mutex, Semaphore, allKeyed, delay, limitAsync, timeout, withTimeout };

package/dist/promise/index.d.ts

@@ -1,7 +1,8 @@
+import { limitAsync } from "./limitAsync.js";
 import { allKeyed } from "./allKeyed.js";
 import { delay } from "./delay.js";
 import { Mutex } from "./mutex.js";
 import { Semaphore } from "./semaphore.js";
 import { timeout } from "./timeout.js";
 import { withTimeout } from "./withTimeout.js";
-export { Mutex, Semaphore, allKeyed, delay, timeout, withTimeout };
+export { Mutex, Semaphore, allKeyed, delay, limitAsync, timeout, withTimeout };

package/dist/promise/index.js

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_semaphore = require("./semaphore.js");
+const require_limitAsync = require("./limitAsync.js");
 const require_delay = require("./delay.js");
 const require_allKeyed = require("./allKeyed.js");
 const require_mutex = require("./mutex.js");
@@ -9,5 +10,6 @@ exports.Mutex = require_mutex.Mutex;
 exports.Semaphore = require_semaphore.Semaphore;
 exports.allKeyed = require_allKeyed.allKeyed;
 exports.delay = require_delay.delay;
+exports.limitAsync = require_limitAsync.limitAsync;
 exports.timeout = require_timeout.timeout;
 exports.withTimeout = require_withTimeout.withTimeout;

package/dist/promise/index.mjs

@@ -1,7 +1,8 @@
 import { Semaphore } from "./semaphore.mjs";
+import { limitAsync } from "./limitAsync.mjs";
 import { delay } from "./delay.mjs";
 import { allKeyed } from "./allKeyed.mjs";
 import { Mutex } from "./mutex.mjs";
 import { timeout } from "./timeout.mjs";
 import { withTimeout } from "./withTimeout.mjs";
-export { Mutex, Semaphore, allKeyed, delay, timeout, withTimeout };
+export { Mutex, Semaphore, allKeyed, delay, limitAsync, timeout, withTimeout };

package/dist/promise/limitAsync.d.mts

@@ -0,0 +1,35 @@
+//#region src/promise/limitAsync.d.ts
+/**
+ * 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 callback The async function to wrap with concurrency control.
+ * @param concurrency Maximum number of concurrent executions allowed.
+ * @returns 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;
+//#endregion
+export { limitAsync };

package/dist/promise/limitAsync.d.ts

@@ -0,0 +1,35 @@
+//#region src/promise/limitAsync.d.ts
+/**
+ * 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 callback The async function to wrap with concurrency control.
+ * @param concurrency Maximum number of concurrent executions allowed.
+ * @returns 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;
+//#endregion
+export { limitAsync };

package/dist/promise/limitAsync.js

@@ -0,0 +1,46 @@
+const require_semaphore = require("./semaphore.js");
+//#region src/promise/limitAsync.ts
+/**
+* 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 callback The async function to wrap with concurrency control.
+* @param concurrency Maximum number of concurrent executions allowed.
+* @returns 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)));
+*/
+function limitAsync(callback, concurrency) {
+	const semaphore = new require_semaphore.Semaphore(concurrency);
+	return async function(...args) {
+		try {
+			await semaphore.acquire();
+			return await callback.apply(this, args);
+		} finally {
+			semaphore.release();
+		}
+	};
+}
+//#endregion
+exports.limitAsync = limitAsync;

package/dist/promise/limitAsync.mjs

@@ -0,0 +1,46 @@
+import { Semaphore } from "./semaphore.mjs";
+//#region src/promise/limitAsync.ts
+/**
+* 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 callback The async function to wrap with concurrency control.
+* @param concurrency Maximum number of concurrent executions allowed.
+* @returns 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)));
+*/
+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();
+		}
+	};
+}
+//#endregion
+export { limitAsync };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "es-toolkit",
-  "version": "1.50.0-dev.2048+51b4612f",
+  "version": "1.50.0-dev.2050+ad4815bf",
   "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",