Add constrained promise parallelism

Added a new method that runs at most a certain number of Promises at a time.
Allows a balance of resource usage safety and speed.

It's faster than sequential, but know we won't end up queuing so many
promises we end up with resource starvation.
I.e. restoring against 87 projects in the FAKE repo

src/Components/TestExplorer.fs

@@ -923,7 +923,9 @@ module Interactions =
     let refreshTestList testItemFactory (rootTestCollection: TestItemCollection) tryGetLocation =
         promise {
 
-            let! _ = ProjectExt.getAllWorkspaceProjects () |> Promise.executeForAll DotnetCli.restore
+            let! _ =
+                ProjectExt.getAllWorkspaceProjects ()
+                |> Promise.executeWithMaxParallel 4 DotnetCli.restore
 
             let testProjectPaths =
                 Project.getInWorkspace ()
@@ -947,8 +949,8 @@ module Interactions =
 
             let! _ =
                 testProjectPaths
-                |> List.map (fun projectPath -> DotnetCli.dotnetTest projectPath [| "--no-build" |])
-                |> Promise.Parallel
+                |> Promise.executeWithMaxParallel 2 (fun projectPath ->
+                    DotnetCli.dotnetTest projectPath [| "--no-build" |])
 
             let newTests =
                 TestDiscovery.discoverFromTrx testItemFactory tryGetLocation () |> ResizeArray

src/Core/Utils.fs

@@ -302,6 +302,23 @@ module Promise =
         | [ x ] -> f x
         | x :: tail -> tail |> List.fold (fun acc next -> acc |> Promise.bind (fun _ -> f next)) (f x)
 
+    let executeWithMaxParallel maxParallelCount (f: 'a -> JS.Promise<'b>) (items: 'a list) =
+        let initial = items |> List.take maxParallelCount
+
+        let mutable remaining =
+            Collections.Generic.Queue(collection = (items |> List.skip maxParallelCount))
+
+        let rec startNext promise =
+            promise
+            |> Promise.bind (fun _ ->
+                if remaining.Count = 0 then
+                    promise
+                else
+                    let next: 'a = remaining.Dequeue()
+                    startNext (f next))
+
+        initial |> List.map (f >> startNext) |> Promise.all
+
 module Event =
 
     let invoke (listener: 'T -> _) (event: Fable.Import.VSCode.Vscode.Event<'T>) = event.Invoke(listener >> unbox)