Fix event and JS component args serialization

src/Components/Components/src/ParameterViewBuilder.cs

@@ -18,10 +18,10 @@ internal readonly struct ParameterViewBuilder
         /// <summary>
         /// Constructs an instance of <see cref="ParameterViewBuilder" />.
         /// </summary>
-        /// <param name="count">The maximum number of parameters that can be held.</param>
-        public ParameterViewBuilder(int count)
+        /// <param name="maxCapacity">The maximum number of parameters that can be held.</param>
+        public ParameterViewBuilder(int maxCapacity)
         {
-            _frames = new RenderTreeFrame[count + 1];
+            _frames = new RenderTreeFrame[maxCapacity + 1];
             _frames[0] = RenderTreeFrame
                 .Element(0, GeneratedParameterViewElementName)
                 .WithElementSubtreeLength(1);
@@ -44,10 +44,6 @@ public void Add(string name, object? value)
         /// <returns>The <see cref="ParameterView" />.</returns>
         public ParameterView ToParameterView()
         {
-            // Since this is internal, we should expect the usage to always be correct,
-            // i.e. the given count should match the number of 'Add' calls.
-            Debug.Assert(_frames[0].ElementSubtreeLengthField == _frames.Length);
-
             return new ParameterView(ParameterViewLifetime.Unbound, _frames, 0);
         }
     }

src/Components/Ignitor/src/BlazorClient.cs

@@ -9,6 +9,7 @@
 using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.AspNetCore.Components.RenderTree;
 using Microsoft.AspNetCore.SignalR.Client;
 using Microsoft.AspNetCore.SignalR.Protocol;
 using Microsoft.Extensions.DependencyInjection;
@@ -160,11 +161,11 @@ public Task ClickAsync(string elementId, bool expectRenderBatch = true)
             }
             if (expectRenderBatch)
             {
-                return ExpectRenderBatch(() => elementNode.ClickAsync(HubConnection));
+                return ExpectRenderBatch(() => elementNode.ClickAsync(this));
             }
             else
             {
-                return elementNode.ClickAsync(HubConnection);
+                return elementNode.ClickAsync(this);
             }
         }
 
@@ -175,7 +176,27 @@ public Task SelectAsync(string elementId, string value)
                 throw new InvalidOperationException($"Could not find element with id {elementId}.");
             }
 
-            return ExpectRenderBatch(() => elementNode.SelectAsync(HubConnection, value));
+            return ExpectRenderBatch(() => elementNode.SelectAsync(this, value));
+        }
+
+        public Task DispatchEventAsync(object descriptor, EventArgs eventArgs)
+        {
+            var attachWebRendererInteropCall = Operations.JSInteropCalls.FirstOrDefault(c => c.Identifier == "Blazor._internal.attachWebRendererInterop");
+            if (attachWebRendererInteropCall is null)
+            {
+                throw new InvalidOperationException("The server has not yet attached interop methods, so events cannot be dispatched.");
+            }
+
+            var args = JsonSerializer.Deserialize<JsonElement>(attachWebRendererInteropCall.ArgsJson);
+            var dotNetObjectRef = args.EnumerateArray().Skip(1).First();
+            var dotNetObjectId = dotNetObjectRef.GetProperty("__dotNetObject").GetInt32();
+
+            return InvokeDotNetMethod(
+                null,
+                null,
+                "DispatchEventAsync",
+                dotNetObjectId,
+                JsonSerializer.Serialize(new object[] { descriptor, eventArgs }, new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase }));
         }
 
         public async Task<CapturedRenderBatch?> ExpectRenderBatch(Func<Task> action, TimeSpan? timeout = null)
@@ -483,7 +504,7 @@ private Uri GetHubUrl(Uri uri)
             }
         }
 
-        public async Task InvokeDotNetMethod(object callId, string assemblyName, string methodIdentifier, object dotNetObjectId, string argsJson)
+        public async Task InvokeDotNetMethod(object? callId, string? assemblyName, string methodIdentifier, object dotNetObjectId, string argsJson)
         {
             await ExpectDotNetInterop(() => HubConnection.InvokeAsync(
                 "BeginInvokeDotNetFromJS",

src/Components/Ignitor/src/ElementNode.cs

@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Text.Json;
 using System.Threading.Tasks;
+using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.RenderTree;
 using Microsoft.AspNetCore.SignalR.Client;
 
@@ -62,21 +63,31 @@ public void SetEvent(string eventName, ElementEventDescriptor descriptor)
             _events[eventName] = descriptor;
         }
 
-        internal Task SelectAsync(HubConnection connection, string value)
+        class TestChangeEventArgs : EventArgs
+        {
+            public object? Value { get; set; }
+        }
+
+        class TestMouseEventArgs : EventArgs
+        {
+            public string? Type { get; set; }
+            public int Detail { get; set; }
+        }
+
+        internal Task SelectAsync(BlazorClient client, string value)
         {
             if (!Events.TryGetValue("change", out var changeEventDescriptor))
             {
                 throw new InvalidOperationException("Element does not have a change event.");
             }
 
-            var args = new
+            var args = new TestChangeEventArgs
             {
                 Value = value
             };
 
             var webEventDescriptor = new WebEventDescriptor
             {
-                BrowserRendererId = 0,
                 EventHandlerId = changeEventDescriptor.EventId,
                 EventName = "change",
                 EventFieldInfo = new EventFieldInfo
@@ -86,36 +97,32 @@ internal Task SelectAsync(HubConnection connection, string value)
                 }
             };
 
-            return DispatchEventCore(connection, Serialize(webEventDescriptor), Serialize(args));
+            return DispatchEventCore(client, webEventDescriptor, args);
         }
 
-        public Task ClickAsync(HubConnection connection)
+        public Task ClickAsync(BlazorClient client)
         {
             if (!Events.TryGetValue("click", out var clickEventDescriptor))
             {
                 throw new InvalidOperationException("Element does not have a click event.");
             }
 
-            var mouseEventArgs = new
+            var mouseEventArgs = new TestMouseEventArgs
             {
                 Type = clickEventDescriptor.EventName,
                 Detail = 1
             };
             var webEventDescriptor = new WebEventDescriptor
             {
-                BrowserRendererId = 0,
                 EventHandlerId = clickEventDescriptor.EventId,
                 EventName = "click",
             };
 
-            return DispatchEventCore(connection, Serialize(webEventDescriptor), Serialize(mouseEventArgs));
+            return DispatchEventCore(client, webEventDescriptor, mouseEventArgs);
         }
 
-        private static byte[] Serialize<T>(T payload) =>
-             JsonSerializer.SerializeToUtf8Bytes(payload, new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });
-
-        private static Task DispatchEventCore(HubConnection connection, byte[] descriptor, byte[] eventArgs) =>
-            connection.InvokeAsync("DispatchBrowserEvent", descriptor, eventArgs);
+        private static Task DispatchEventCore(BlazorClient client, WebEventDescriptor descriptor, EventArgs eventArgs) =>
+            client.DispatchEventAsync(descriptor, eventArgs);
 
         public class ElementEventDescriptor
         {

src/Components/Server/src/Circuits/CircuitFactory.cs

@@ -66,13 +66,15 @@ public async ValueTask<CircuitHost> CreateCircuitHostAsync(
             var appLifetime = scope.ServiceProvider.GetRequiredService<ComponentApplicationLifetime>();
             await appLifetime.RestoreStateAsync(store);
 
+            var jsComponentInterop = new CircuitJSComponentInterop(_options);
             var renderer = new RemoteRenderer(
                 scope.ServiceProvider,
                 _loggerFactory,
                 _options,
                 client,
                 _loggerFactory.CreateLogger<RemoteRenderer>(),
-                jsRuntime.ElementReferenceContext);
+                jsRuntime,
+                jsComponentInterop);
 
             var circuitHandlers = scope.ServiceProvider.GetServices<CircuitHandler>()
                 .OrderBy(h => h.Order)

src/Components/Server/src/Circuits/CircuitHost.cs

@@ -105,11 +105,6 @@ public Task InitializeAsync(ProtectedPrerenderComponentApplicationStore store, C
                     await OnCircuitOpenedAsync(cancellationToken);
                     await OnConnectionUpAsync(cancellationToken);
 
-                    // From this point onwards, JavaScript code can add root components if configured
-                    await Renderer.InitializeJSComponentSupportAsync(
-                        _options.RootComponents.JSComponents,
-                        JSRuntime.ReadJsonSerializerOptions());
-
                     // Here, we add each root component but don't await the returned tasks so that the
                     // components can be processed in parallel.
                     var count = Descriptors.Count;
@@ -445,49 +440,6 @@ internal async Task<bool> ReceiveJSDataChunk(long streamId, long chunkId, byte[]
             }
         }
 
-        // DispatchEvent is used in a fire-and-forget context, so it's responsible for its own
-        // error handling.
-        public async Task DispatchEvent(JsonElement eventDescriptorJson, JsonElement eventArgsJson)
-        {
-            AssertInitialized();
-            AssertNotDisposed();
-
-            WebEventData webEventData;
-            try
-            {
-                // JsonSerializerOptions are tightly bound to the JsonContext. Cache it on first use using a copy
-                // of the serializer settings.
-                webEventData = WebEventData.Parse(Renderer, JSRuntime.ReadJsonSerializerOptions(), eventDescriptorJson, eventArgsJson);
-            }
-            catch (Exception ex)
-            {
-                // Invalid event data is fatal. We expect a well-behaved client to send valid JSON.
-                Log.DispatchEventFailedToParseEventData(_logger, ex);
-                await TryNotifyClientErrorAsync(Client, GetClientErrorMessage(ex, "Bad input data."));
-                UnhandledException?.Invoke(this, new UnhandledExceptionEventArgs(ex, isTerminating: false));
-                return;
-            }
-
-            try
-            {
-                await Renderer.Dispatcher.InvokeAsync(() =>
-                {
-                    return Renderer.DispatchEventAsync(
-                        webEventData.EventHandlerId,
-                        webEventData.EventFieldInfo,
-                        webEventData.EventArgs);
-                });
-            }
-            catch (Exception ex)
-            {
-                // A failure in dispatching an event means that it was an attempt to use an invalid event id.
-                // A well-behaved client won't do this.
-                Log.DispatchEventFailedToDispatchEvent(_logger, webEventData.EventHandlerId.ToString(CultureInfo.InvariantCulture), ex);
-                await TryNotifyClientErrorAsync(Client, GetClientErrorMessage(ex, "Failed to dispatch event."));
-                UnhandledException?.Invoke(this, new UnhandledExceptionEventArgs(ex, isTerminating: false));
-            }
-        }
-
         // OnLocationChangedAsync is used in a fire-and-forget context, so it's responsible for its own
         // error handling.
         public async Task OnLocationChangedAsync(string uri, bool intercepted)

src/Components/Server/src/Circuits/CircuitJSComponentInterop.cs

@@ -1,37 +1,22 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.ComponentModel;
-using System.Text.Json;
-using Microsoft.AspNetCore.Components.Web;
 using Microsoft.AspNetCore.Components.Web.Infrastructure;
-using Microsoft.JSInterop;
 
 namespace Microsoft.AspNetCore.Components.Server.Circuits
 {
-    /// <summary>
-    /// Intended for framework use only. Not supported for use from application code.
-    /// </summary>
-    [EditorBrowsable(EditorBrowsableState.Never)]
-    public class CircuitJSComponentInterop : JSComponentInterop
+    internal class CircuitJSComponentInterop : JSComponentInterop
     {
         private readonly CircuitOptions _circuitOptions;
         private int _jsRootComponentCount;
 
-        internal CircuitJSComponentInterop(
-            JSComponentConfigurationStore configuration,
-            JsonSerializerOptions jsonOptions,
-            CircuitOptions circuitOptions)
-            : base(configuration, jsonOptions)
+        internal CircuitJSComponentInterop(CircuitOptions circuitOptions)
+            : base(circuitOptions.RootComponents.JSComponents)
         {
             _circuitOptions = circuitOptions;
         }
 
-        /// <summary>
-        /// For framework use only.
-        /// </summary>
-        [JSInvokable]
-        public override int AddRootComponent(string identifier, string domElementSelector)
+        protected override int AddRootComponent(string identifier, string domElementSelector)
         {
             if (_jsRootComponentCount >= _circuitOptions.RootComponents.MaxJSRootComponents)
             {
@@ -43,11 +28,7 @@ public override int AddRootComponent(string identifier, string domElementSelecto
             return id;
         }
 
-        /// <summary>
-        /// For framework use only.
-        /// </summary>
-        [JSInvokable]
-        public override void RemoveRootComponent(int componentId)
+        protected override void RemoveRootComponent(int componentId)
         {
             base.RemoveRootComponent(componentId);
 

src/Components/Server/src/Circuits/RemoteRenderer.cs

@@ -36,14 +36,15 @@ public RemoteRenderer(
             CircuitOptions options,
             CircuitClientProxy client,
             ILogger logger,
-            ElementReferenceContext? elementReferenceContext)
-            : base(serviceProvider, loggerFactory)
+            RemoteJSRuntime jsRuntime,
+            CircuitJSComponentInterop jsComponentInterop)
+            : base(serviceProvider, loggerFactory, jsRuntime.ReadJsonSerializerOptions(), jsComponentInterop)
         {
             _client = client;
             _options = options;
             _logger = logger;
 
-            ElementReferenceContext = elementReferenceContext;
+            ElementReferenceContext = jsRuntime.ElementReferenceContext;
         }
 
         public override Dispatcher Dispatcher { get; } = Dispatcher.CreateDefault();
@@ -311,12 +312,6 @@ private static void CompleteRender(TaskCompletionSource pendingRenderInfo, strin
             }
         }
 
-        public ValueTask InitializeJSComponentSupportAsync(JSComponentConfigurationStore configuration, JsonSerializerOptions jsonOptions)
-        {
-            var interop = new CircuitJSComponentInterop(configuration, jsonOptions, _options);
-            return InitializeJSComponentSupportAsync(interop);
-        }
-
         internal readonly struct UnacknowledgedRenderBatch
         {
             public UnacknowledgedRenderBatch(long batchId, ArrayBuilder<byte> data, TaskCompletionSource completionSource, ValueStopwatch valueStopwatch)

src/Components/Server/src/ComponentHub.cs

@@ -242,21 +242,6 @@ public async ValueTask<bool> ReceiveJSDataChunk(long streamId, long chunkId, byt
             return await circuitHost.ReceiveJSDataChunk(streamId, chunkId, chunk, error);
         }
 
-        public async ValueTask DispatchBrowserEvent(JsonElement eventInfo)
-        {
-            Debug.Assert(eventInfo.GetArrayLength() == 2, "Array length should be 2");
-            var eventDescriptor = eventInfo[0];
-            var eventArgs = eventInfo[1];
-
-            var circuitHost = await GetActiveCircuitAsync();
-            if (circuitHost == null)
-            {
-                return;
-            }
-
-            _ = circuitHost.DispatchEvent(eventDescriptor, eventArgs);
-        }
-
         public async ValueTask OnRenderCompleted(long renderId, string errorMessageOrNull)
         {
             var circuitHost = await GetActiveCircuitAsync();

src/Components/Server/src/PublicAPI.Unshipped.txt

@@ -5,6 +5,3 @@ Microsoft.AspNetCore.Components.Server.CircuitRootComponentOptions.CircuitRootCo
 Microsoft.AspNetCore.Components.Server.CircuitRootComponentOptions.JSComponents.get -> Microsoft.AspNetCore.Components.Web.JSComponentConfigurationStore!
 Microsoft.AspNetCore.Components.Server.CircuitRootComponentOptions.MaxJSRootComponents.get -> int
 Microsoft.AspNetCore.Components.Server.CircuitRootComponentOptions.MaxJSRootComponents.set -> void
-Microsoft.AspNetCore.Components.Server.Circuits.CircuitJSComponentInterop
-override Microsoft.AspNetCore.Components.Server.Circuits.CircuitJSComponentInterop.AddRootComponent(string! identifier, string! domElementSelector) -> int
-override Microsoft.AspNetCore.Components.Server.Circuits.CircuitJSComponentInterop.RemoveRootComponent(int componentId) -> void