feat: support max parallel count

src/index.ts

@@ -8,7 +8,7 @@ import * as path from "node:path";
 import { Readable } from "node:stream";
 import * as urllib from "urllib";
 import * as yauzl from "yauzl";
-import { awaitEvent, createPromiseResolvers, retry } from "./utils";
+import { awaitEvent, createPromiseResolvers, parallelRunPromise, retry } from "./utils";
 
 const debug = debugFactory("InstallExtension");
 
@@ -298,10 +298,19 @@ export class ExtensionInstaller implements IExtensionInstaller {
       : [];
   }
 
-  private async installExtensions(exts: Extension[]): Promise<string[]> {
-    const result = await Promise.all(exts.map((e: Extension) => {
-      return this.install(e);
-    }));
+  private async installExtensions(exts: Extension[], maxParallel?: number): Promise<string[]> {
+    let result: string[][] = [];
+    if (maxParallel) {
+      result = await parallelRunPromise(
+        exts.map((e: Extension) => {
+          return () => this.install(e);
+        }),
+        maxParallel,
+      );
+    } else {
+      result = await Promise.all(exts.map((e: Extension) => this.install(e)));
+    }
+
     return result.flat(Infinity) as string[];
   }
 

src/utils.ts

@@ -89,3 +89,36 @@ export const createPromiseResolvers = <T>(): IDeferred<T> => {
 
   return { promise, resolve: resolve!, reject: reject! };
 };
+
+// 限制并发数，运行promise
+export const parallelRunPromise = <T>(lazyPromises: (() => Promise<T>)[], n: number) => {
+  const results: T[] = [];
+  let index = 0;
+  let working = 0;
+  let complete = 0;
+
+  const addWorking = (resolve: (value: T[]) => void, reject: (error: Error) => void) => {
+    while (working < n && index < lazyPromises.length) {
+      const current = lazyPromises[index++];
+      working++;
+
+      ((index) => {
+        current().then((result) => {
+          working--;
+          complete++;
+          results[index] = result;
+
+          if (complete === lazyPromises.length) {
+            resolve(results);
+            return;
+          }
+
+          // note: 虽然addWorking中有while，这里其实每次只会加一个promise
+          addWorking(resolve, reject);
+        }, reject);
+      })(index - 1);
+    }
+  };
+
+  return new Promise(addWorking);
+};