perf(core): replace neo-async with a minimal helper (#8282)

* perf(core): replace `neo-async` with a minimal helper

* fix: lock

packages/rspack/package.json

@@ -52,15 +52,13 @@
     "@swc/core": "1.4.0",
     "@swc/types": "0.1.12",
     "@types/graceful-fs": "4.1.9",
-    "@types/neo-async": "^2.6.6",
     "@types/watchpack": "^2.4.0",
     "@types/webpack-sources": "3.2.3",
     "browserslist": "^4.21.3",
     "cross-env": "^7.0.3",
     "enhanced-resolve": "5.12.0",
     "graceful-fs": "4.2.10",
     "json-parse-even-better-errors": "^3.0.0",
-    "neo-async": "2.6.2",
     "prebundle": "^1.1.0",
     "tsc-alias": "^1.8.8",
     "tsup": "^8.3.0",

packages/rspack/src/MultiCompiler.ts

@@ -9,13 +9,13 @@
  */
 
 import * as liteTapable from "@rspack/lite-tapable";
-import asyncLib from "neo-async";
 import type { Compiler, RspackOptions, Stats } from ".";
 import MultiStats from "./MultiStats";
 import MultiWatching from "./MultiWatching";
 import type { WatchOptions } from "./config";
 import ConcurrentCompilationError from "./error/ConcurrentCompilationError";
 import ArrayQueue from "./util/ArrayQueue";
+import asyncLib from "./util/asyncLib";
 import type { InputFileSystem, WatchFileSystem } from "./util/fs";
 
 interface Node<T> {

packages/rspack/src/MultiWatching.ts

@@ -8,7 +8,7 @@
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
 
-import asyncLib from "neo-async";
+import asyncLib from "./util/asyncLib";
 
 import type { Callback } from "@rspack/lite-tapable";
 import type { MultiCompiler } from "./MultiCompiler";
@@ -43,7 +43,7 @@ class MultiWatching {
 	}
 
 	close(callback: Callback<Error, void>) {
-		asyncLib.forEach(
+		asyncLib.each(
 			this.watchings,
 			(watching, finishedCallback) => {
 				watching.close(finishedCallback);

packages/rspack/src/lib/CacheFacade.ts

@@ -8,7 +8,7 @@
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
 
-import asyncLib from "neo-async";
+import asyncLib from "../util/asyncLib";
 import { getter as getLazyHashedEtag } from "./cache/getLazyHashedEtag.js";
 import { mergeEtags } from "./cache/mergeEtags.js";
 

packages/rspack/src/util/asyncLib.ts

@@ -0,0 +1,116 @@
+/**
+ * The following code is modified based on
+ * https://github.com/suguru03/neo-async/blob/master/lib/async.js
+ *
+ * MIT Licensed
+ * Author Suguru Motegi
+ * Copyright (c) 2014-2018 Suguru Motegi
+ * https://github.com/suguru03/neo-async/blob/master/LICENSE
+ */
+export interface Dictionary<T> {
+	[key: string]: T;
+}
+export type IterableCollection<T> = T[] | IterableIterator<T> | Dictionary<T>;
+export type ErrorCallback<E = Error> = (err?: E | null) => void;
+export type AsyncIterator<T, E = Error> = (
+	item: T,
+	callback: ErrorCallback<E>
+) => void;
+
+function throwError() {
+	throw new Error("Callback was already called.");
+}
+
+function noop() {}
+
+function onlyOnce<E = Error>(func: ErrorCallback<E>): ErrorCallback<E> {
+	return (err?: E | null) => {
+		const fn = func;
+		// biome-ignore lint/style/noParameterAssign:
+		func = throwError;
+		fn(err);
+	};
+}
+
+function once<E = Error>(func: ErrorCallback<E>): ErrorCallback<E> {
+	return (err?: E | null) => {
+		const fn = func;
+		// biome-ignore lint/style/noParameterAssign:
+		func = noop;
+		fn(err);
+	};
+}
+
+function arrayEach<T, E = Error>(
+	array: T[],
+	iterator: (item: T, callback: ErrorCallback<E>) => void,
+	callback: ErrorCallback<E>
+): void {
+	let index = -1;
+	while (++index < array.length) {
+		iterator(array[index], onlyOnce(callback));
+	}
+}
+
+/**
+ * @example
+ *
+ * // array
+ * var order = [];
+ * var array = [1, 3, 2];
+ * var iterator = function(num, done) {
+ *   setTimeout(function() {
+ *     order.push(num);
+ *     done();
+ *   }, num * 10);
+ * };
+ * asyncLib.each(array, iterator, function(err, res) {
+ *   console.log(res); // undefined
+ *   console.log(order); // [1, 2, 3]
+ * });
+ *
+ * @example
+ *
+ * // break
+ * var order = [];
+ * var array = [1, 3, 2];
+ * var iterator = function(num, done) {
+ *   setTimeout(function() {
+ *     order.push(num);
+ *     done(null, num !== 2);
+ *   }, num * 10);
+ * };
+ * asyncLib.each(array, iterator, function(err, res) {
+ *   console.log(res); // undefined
+ *   console.log(order); // [1, 2]
+ * });
+ *
+ */
+function each<T, E = Error>(
+	collection: IterableCollection<T>,
+	iterator: AsyncIterator<T, E>,
+	originalCallback: ErrorCallback<E>
+) {
+	let callback = once(originalCallback);
+	let size = 0;
+	let completed = 0;
+
+	const done: ErrorCallback<E> = err => {
+		if (err) {
+			callback = once(callback);
+			callback(err);
+		} else if (++completed === size) {
+			callback(null);
+		}
+	};
+
+	if (Array.isArray(collection)) {
+		size = collection.length;
+		arrayEach(collection, iterator, done);
+	}
+	if (!size) {
+		callback(null);
+	}
+}
+
+export default { each };