Fixed issues with submitCommandAndGetResult functionality

src/Microsoft.DotNet.Interactive.CSharpProject.Tests/CSharpProjectKernelCommandOrderTests.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using FluentAssertions;
 using FluentAssertions.Execution;
@@ -52,6 +53,7 @@ public async Task OpenProject_returns_a_full_list_of_available_project_items()
 #endregion
 
 #region region-two
+var a = 2;
 #endregion
 "),
             })));
@@ -64,9 +66,9 @@ public async Task OpenProject_returns_a_full_list_of_available_project_items()
                 .Should()
                 .BeEquivalentTo(new[]
                 {
-                    new ProjectItem("./FileWithNoRegions.cs", Array.Empty<string>()),
-                    new ProjectItem("./FileWithOneRegion.cs", new[] { "only-region" }),
-                    new ProjectItem("./FileWithTwoRegions.cs", new[] { "region-one", "region-two" }),
+                    new ProjectItem("./FileWithNoRegions.cs", Array.Empty<string>(), new Dictionary<string, string>()),
+                    new ProjectItem("./FileWithOneRegion.cs", new[] { "only-region" }, new Dictionary<string, string>{[ "only-region"]= string.Empty}),
+                    new ProjectItem("./FileWithTwoRegions.cs", new[] { "region-one", "region-two" },new Dictionary<string, string>{[ "region-one"]= string.Empty,[ "region-two"]= "var a = 2;"}),
                 });
         }
 

src/Microsoft.DotNet.Interactive.CSharpProject.Tests/SerializationTests.Event_contract_has_not_been_broken.approved.ProjectOpened.json

@@ -5,7 +5,10 @@
         "relativeFilePath": "./Program.cs",
         "regionNames": [
           "some-region"
-        ]
+        ],
+        "regionsContent": {
+          "some-region": ""
+        }
       }
     ]
   },

src/Microsoft.DotNet.Interactive.CSharpProject.Tests/SerializationTests.cs

@@ -200,7 +200,7 @@ IEnumerable<KernelEvent> events()
                     })),
                     new[]
                     {
-                        new ProjectItem("./Program.cs", new[] { "some-region" })
+                        new ProjectItem("./Program.cs", new[] { "some-region" }, new Dictionary<string, string>{["some-region"] = string.Empty})
                     });
             }
         }

src/Microsoft.DotNet.Interactive.CSharpProject/ProjectItem.cs

@@ -3,27 +3,27 @@
 
 using System.Collections.Generic;
 using System.Text.Json.Serialization;
-using Microsoft.DotNet.Interactive.CSharpProject.Tools;
 
-namespace Microsoft.DotNet.Interactive.CSharpProject
+namespace Microsoft.DotNet.Interactive.CSharpProject;
+
+public class ProjectItem
 {
-    public class ProjectItem
-    {
-        private readonly RelativeFilePath _relativeFilePath;
-        public string RelativeFilePath => _relativeFilePath.ToString();
+    private readonly RelativeFilePath _relativeFilePath;
+    public string RelativeFilePath => _relativeFilePath.ToString();
 
-        public IReadOnlyList<string> RegionNames { get; }
+    public IReadOnlyList<string> RegionNames { get; }
+    public IReadOnlyDictionary<string, string> RegionsContent { get; }
 
-        public ProjectItem(RelativeFilePath relativeFilePath, IReadOnlyList<string> regionNames)
-        {
-            _relativeFilePath = relativeFilePath;
-            RegionNames = regionNames;
-        }
+    public ProjectItem(RelativeFilePath relativeFilePath, IReadOnlyList<string> regionNames, IReadOnlyDictionary<string,string> regionsContent)
+    {
+        _relativeFilePath = relativeFilePath;
+        RegionNames = regionNames;
+        RegionsContent = regionsContent;
+    }
 
-        [JsonConstructor]
-        public ProjectItem(string relativeFilePath, IReadOnlyList<string> regionNames)
-            : this(new RelativeFilePath(relativeFilePath), regionNames)
-        {
-        }
+    [JsonConstructor]
+    public ProjectItem(string relativeFilePath, IReadOnlyList<string> regionNames, IReadOnlyDictionary<string, string> regionsContent)
+        : this(new RelativeFilePath(relativeFilePath), regionNames, regionsContent)
+    {
     }
 }

src/microsoft-dotnet-interactive/src/contracts.ts

@@ -477,6 +477,7 @@ export interface ProjectFile {
 export interface ProjectItem {
     relativeFilePath: string;
     regionNames: Array<string>;
+    regionsContent: { [key: string]: string; };
 }
 
 export enum RequestType {

src/microsoft-dotnet-interactive/src/javascriptKernel.ts

@@ -41,7 +41,7 @@ export class JavascriptKernel extends kernel.Kernel {
             capture.dispose();
             capture = undefined;
 
-            throw e;
+            throw e;//?
         }
         finally {
             if (capture) {

src/microsoft-dotnet-interactive/src/kernel.ts

@@ -7,6 +7,7 @@ import * as contracts from "./contracts";
 import { Logger } from "./logger";
 import { CompositeKernel } from "./compositeKernel";
 import { KernelCommandScheduler } from "./kernelCommandScheduler";
+import { PromiseCompletionSource } from "./genericChannel";
 
 export interface IKernelCommandInvocation {
     commandEnvelope: contracts.KernelCommandEnvelope;
@@ -120,7 +121,7 @@ export class Kernel {
 
     handleCommand(commandEnvelope: contracts.KernelCommandEnvelope): Promise<void> {
         return new Promise<void>(async (resolve, reject) => {
-            let context = KernelInvocationContext.establish(commandEnvelope);
+            let context = KernelInvocationContext.establish(commandEnvelope);//?
             context.handlingKernel = this;
             let isRootCommand = areCommandsTheSame(context.commandEnvelope, commandEnvelope);
 
@@ -186,35 +187,45 @@ export class Kernel {
     }
 }
 
-export function submitCommandAndGetResult<TEvent extends contracts.KernelEvent>(kernel: Kernel, commandEnvelope: contracts.KernelCommandEnvelope, expectedEventType: contracts.KernelEventType): Promise<TEvent> {
-    return new Promise<TEvent>(async (resolve, reject) => {
-        let handled = false;
-        const disposable = kernel.subscribeToKernelEvents(eventEnvelope => {
-            if (eventEnvelope.command?.token === commandEnvelope.token) {
-                switch (eventEnvelope.eventType) {
-                    case contracts.CommandFailedType:
-                        if (!handled) {
-                            handled = true;
-                            let err = <contracts.CommandFailed>eventEnvelope.event;
-                            reject(err);
-                        }
-                        break;
-                    case contracts.CommandSucceededType:
-                        if (!handled) {
-                            handled = true;
-                            reject('Command was handled before reporting expected result.');
-                        }
-                        break;
-                    default:
-                        if (eventEnvelope.eventType === expectedEventType) {
+export async function submitCommandAndGetResult<TEvent extends contracts.KernelEvent>(kernel: Kernel, commandEnvelope: contracts.KernelCommandEnvelope, expectedEventType: contracts.KernelEventType): Promise<TEvent> {
+    let completionSource = new PromiseCompletionSource<TEvent>();
+    let handled = false;
+    let disposable = kernel.subscribeToKernelEvents(eventEnvelope => {
+        if (eventEnvelope.command?.token === commandEnvelope.token) {
+            switch (eventEnvelope.eventType) {
+                case contracts.CommandFailedType:
+                    if (!handled) {
+                        handled = true;
+                        let err = <contracts.CommandFailed>eventEnvelope.event;//?
+                        completionSource.reject(err);
+                    }
+                    break;
+                case contracts.CommandSucceededType:
+                    if (areCommandsTheSame(eventEnvelope.command!, commandEnvelope)
+                        && (eventEnvelope.command?.id === commandEnvelope.id)) {
+                        if (!handled) {//? ($ ? eventEnvelope : {})
                             handled = true;
-                            let event = <TEvent>eventEnvelope.event;
-                            resolve(event);
+                            completionSource.reject('Command was handled before reporting expected result.');
                         }
                         break;
-                }
+                    }
+                default:
+                    if (eventEnvelope.eventType === expectedEventType) {
+                        handled = true;
+                        let event = <TEvent>eventEnvelope.event;//? ($ ? eventEnvelope : {})
+                        completionSource.resolve(event);
+                    }
+                    break;
             }
-        });
-        kernel.send(commandEnvelope).finally(() => disposable.dispose());
+        }
     });
+
+    try {
+        await kernel.send(commandEnvelope);
+    }
+    finally {
+        disposable.dispose();
+    }
+
+    return completionSource.promise;
 }

src/microsoft-dotnet-interactive/tests/kernel.test.ts

@@ -4,7 +4,8 @@
 import { expect } from "chai";
 import { describe } from "mocha";
 import * as contracts from "../src/contracts";
-import { IKernelCommandInvocation, Kernel } from "../src/kernel";
+import { JavascriptKernel } from "../src/javascriptKernel";
+import { IKernelCommandInvocation, Kernel, submitCommandAndGetResult } from "../src/kernel";
 import { Logger } from "../src/logger";
 
 interface CustomCommand1 extends contracts.KernelCommand {
@@ -118,5 +119,12 @@ describe("dotnet-interactive", () => {
 
             expect(events.find(e => e.eventType === contracts.CommandFailedType)).is.not.null;
         });
+
+        it("can submit a command and wait for a specific event", async () => {
+            let kernel = new JavascriptKernel();
+            const command: contracts.SubmitCode = { code: "return 1+1;" };
+            let event = await submitCommandAndGetResult<contracts.ReturnValueProduced>(kernel, { commandType: contracts.SubmitCodeType, command: command }, contracts.ReturnValueProducedType);
+            expect(event.formattedValues[0].value).to.equal("2");
+        });
     });
 });