html kernel evals script tags

src/Microsoft.DotNet.Interactive.Browser.Tests/HtmlKernelTests.cs

@@ -217,6 +217,30 @@ public async Task JavaScript_kernel_can_see_DOM_changes_made_by_HTML_kernel()
             .ContainSingle(v => v.Value.Contains("<div>hey there!</div>"));
     }
 
+    [FactSkipLinux("Requires Playwright installed")]
+    public async Task html_kernel_evaluates_script_tags()
+    {
+        var connector = new PlaywrightKernelConnector(!Debugger.IsAttached);
+
+        using var htmlKernel = await connector.CreateKernelAsync("html", BrowserKernelLanguage.Html);
+        using var javascriptKernel = await connector.CreateKernelAsync("javascript", BrowserKernelLanguage.JavaScript);
+        await htmlKernel.SendAsync(new SubmitCode("<div><script>myValue = 123;</script></div>"));
+
+        var result = await javascriptKernel.SendAsync(new SubmitCode("return myValue;"));
+
+        var events = result.KernelEvents.ToSubscribedList();
+
+        events.Should().NotContainErrors();
+
+        events
+            .Should()
+            .ContainSingle<ReturnValueProduced>()
+            .Which
+            .FormattedValues
+            .Should()
+            .ContainSingle(v => v.Value.Contains("123"));
+    }
+
     private async Task<Kernel> CreateHtmlProxyKernelAsync()
     {
         var connector = new PlaywrightKernelConnector(!Debugger.IsAttached);

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

@@ -66,11 +66,15 @@ export function htmlDomFragmentInserter(htmlFragment: string, configuration?: Ht
     const updateContainerContent = configuration?.updateContainerContent ?? ((container, htmlFragment) => container.innerHTML = htmlFragment);
     const createMutationObserver = configuration?.createMutationObserver ?? (callback => new MutationObserver(callback));
     let jsEvaluator: (js: string) => Promise<void>;
+
     if (configuration?.jsEvaluator) {
         jsEvaluator = configuration.jsEvaluator;
     } else {
         const AsyncFunction = eval(`Object.getPrototypeOf(async function(){}).constructor`);
-        jsEvaluator = (code) => AsyncFunction("console", code);
+        jsEvaluator = (code) => {
+            const evaluator = AsyncFunction(code);
+            return (<() => Promise<void>>evaluator)();
+        };
     }
     let container = getOrCreateContainer();
 

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

@@ -104,23 +104,26 @@ describe("htmlKernel", () => {
             events.push(e);
         });
 
-        await kernel.send({ commandType: contracts.SubmitCodeType, command: <contracts.SubmitCode>{ code: '<div id="0"><script>foo = 122;</script></div>' } });
+        await kernel.send({ commandType: contracts.SubmitCodeType, command: <contracts.SubmitCode>{ code: '<div id="0"><script type="module">foo = 122;</script><div id="1"><script type="module">bar = 211;</script></div></div>' } });
 
         const lastDisplayedValueProducedEvent = events.filter(e => e.eventType === contracts.DisplayedValueProducedType).at(-1)?.event as contracts.DisplayedValueProduced;
         expect(lastDisplayedValueProducedEvent).to.not.be.undefined;
 
-        expect(lastDisplayedValueProducedEvent).to.deep.equal({
-            displayedValueProduced:
+        expect(lastDisplayedValueProducedEvent).to.deep.equal(
             {
-                formattedValues:
-                    [{
-                        mimeType: 'text/html',
-                        value: '<div id="0"><script>foo = 122;</script></div>'
-                    }]
+                displayedValueProduced:
+                {
+                    formattedValues:
+                        [{
+                            mimeType: 'text/html',
+                            value: '<div id="0"><script type="module">foo = 122;</script><div id="1"><script type="module">bar = 211;</script></div></div>'
+                        }]
+                }
             }
-        });
+        );
 
         expect(dom.window.globalThis["foo"]).to.be.equal(122);
+        expect(dom.window.globalThis["bar"]).to.be.equal(211);
     });
 
     it("can reuse container", async () => {