Fix for the recursive batch rendering bug. Needs more tests though.

Author: SteveSandersonMS

src/Components/Web.JS/dist/Release/blazor.server.js

@@ -89,7 +89,7 @@ async function initializeConnection(options: CircuitStartOptions, logger: Logger
   const connection = connectionBuilder.build();
 
   setEventDispatcher((descriptor, args) => {
-    return connection.send('DispatchBrowserEvent', JSON.stringify(descriptor), JSON.stringify(args));
+    connection.send('DispatchBrowserEvent', JSON.stringify(descriptor), JSON.stringify(args));
   });
 
   // Configure navigation via SignalR

src/Components/Web.JS/dist/Release/blazor.webassembly.js

@@ -22,7 +22,13 @@ async function boot(options?: Partial<WebAssemblyStartOptions>): Promise<void> {
   }
   started = true;
 
-  setEventDispatcher((eventDescriptor, eventArgs) => DotNet.invokeMethodAsync('Microsoft.AspNetCore.Components.WebAssembly', 'DispatchEvent', eventDescriptor, JSON.stringify(eventArgs)));
+  setEventDispatcher((eventDescriptor, eventArgs) => {
+    // It's extremely unusual, but an event can be raised while we're in the middle of synchronously applying a
+    // renderbatch. For example, a renderbatch might mutate the DOM in such a way as to cause an <input> to lose
+    // focus, in turn triggering a 'change' event. It may also be possible to listen to other DOM mutation events
+    // that are themselves triggered by the application of a renderbatch.
+    monoPlatform.invokeWhenHeapUnlocked(() => DotNet.invokeMethodAsync('Microsoft.AspNetCore.Components.WebAssembly', 'DispatchEvent', eventDescriptor, JSON.stringify(eventArgs)));
+  });
 
   // Configure environment for execution under Mono WebAssembly with shared-memory rendering
   const platform = Environment.setPlatform(monoPlatform);

src/Components/Web.JS/src/Boot.Server.ts

@@ -147,6 +147,15 @@ export const monoPlatform: Platform = {
     assertHeapIsNotLocked();
     currentHeapLock = new MonoHeapLock();
     return currentHeapLock;
+  },
+
+  invokeWhenHeapUnlocked: function(callback) {
+    // This is somewhat like a sync context. If we're not locked, just pass through the call directly.
+    if (!currentHeapLock) {
+      callback();
+    } else {
+      currentHeapLock.enqueuePostReleaseAction(callback);
+    }
   }
 };
 
@@ -490,11 +499,31 @@ class MonoHeapLock implements HeapLock {
   // Within a given heap lock, it's safe to cache decoded strings since the memory can't change
   stringCache = new Map<number, string | null>();
 
+  private postReleaseActions?: Function[];
+
+  enqueuePostReleaseAction(callback: Function) {
+    if (!this.postReleaseActions) {
+      this.postReleaseActions = [];
+    }
+
+    this.postReleaseActions.push(callback);
+  }
+
   release() {
     if (currentHeapLock !== this) {
       throw new Error('Trying to release a lock which isn\'t current');
     }
 
     currentHeapLock = null;
+
+    while (this.postReleaseActions?.length) {
+      const nextQueuedAction = this.postReleaseActions.shift()!;
+
+      // It's possible that the action we invoke here might itself take a succession of heap locks,
+      // but since heap locks must be released synchronously, by the time we get back to this stack
+      // frame, we know the heap should no longer be locked.
+      nextQueuedAction();
+      assertHeapIsNotLocked();
+    }
   }
 }

src/Components/Web.JS/src/Boot.WebAssembly.ts

@@ -20,6 +20,7 @@ export interface Platform {
   readStructField<T extends Pointer>(baseAddress: Pointer, fieldOffset?: number): T;
 
   beginHeapLock(): HeapLock;
+  invokeWhenHeapUnlocked(callback: Function): void;
 }
 
 export interface HeapLock {

src/Components/Web.JS/src/Platform/Mono/MonoPlatform.ts

@@ -10,9 +10,9 @@ export function dispatchEvent(eventDescriptor: EventDescriptor, eventArgs: UIEve
     throw new Error('eventDispatcher not initialized. Call \'setEventDispatcher\' to configure it.');
   }
 
-  return eventDispatcherInstance(eventDescriptor, eventArgs);
+  eventDispatcherInstance(eventDescriptor, eventArgs);
 }
 
-export function setEventDispatcher(newDispatcher: (eventDescriptor: EventDescriptor, eventArgs: UIEventArgs) => Promise<void>): void {
+export function setEventDispatcher(newDispatcher: (eventDescriptor: EventDescriptor, eventArgs: UIEventArgs) => void): void {
   eventDispatcherInstance = newDispatcher;
 }