Changes per PR

Author: pranavkm

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

@@ -8,95 +8,84 @@ import { renderBatch } from './Rendering/Renderer';
 import { fetchBootConfigAsync, loadEmbeddedResourcesAsync } from './BootCommon';
 import { CircuitHandler } from './Platform/Circuits/CircuitHandler';
 
-async function boot(reconnect: boolean = false) {
-  const circuitHandlers = new Array<CircuitHandler>();
+async function boot() {
+  const circuitHandlers: CircuitHandler[] = [];
   window['Blazor'].addCircuitHandler = (circuitHandler: CircuitHandler) => circuitHandlers.push(circuitHandler);
 
-  await startCicuit();
-
-  async function startCicuit(): Promise<void> {
-    // In the background, start loading the boot config and any embedded resources
-    const embeddedResourcesPromise = fetchBootConfigAsync().then(bootConfig => {
-      return loadEmbeddedResourcesAsync(bootConfig);
-    });
-
-    const initialConnection = await initializeConnection();
-
-    // Ensure any embedded resources have been loaded before starting the app
-    await embeddedResourcesPromise;
-    const circuitId = await initialConnection.invoke<string>(
-      'StartCircuit',
-      uriHelperFunctions.getLocationHref(),
-      uriHelperFunctions.getBaseURI()
-    );
+  // In the background, start loading the boot config and any embedded resources
+  const embeddedResourcesPromise = fetchBootConfigAsync().then(bootConfig => {
+    return loadEmbeddedResourcesAsync(bootConfig);
+  });
+
+  const initialConnection = await initializeConnection(circuitHandlers);
+
+  // Ensure any embedded resources have been loaded before starting the app
+  await embeddedResourcesPromise;
+  const circuitId = await initialConnection.invoke<string>(
+    'StartCircuit',
+    uriHelperFunctions.getLocationHref(),
+    uriHelperFunctions.getBaseURI()
+  );
+
+  window['Blazor'].reconnect = async () => {
+    const reconnection = await initializeConnection(circuitHandlers);
+    if (!await reconnection.invoke<Boolean>('ConnectCircuit', circuitId)) {
+      throw new Error('Failed to reconnect to the server. The supplied circuitId is no longer valid');
+    }
 
-    window['Blazor'].reconnect = async () => {
-      const reconnection = await initializeConnection();
-      if (!await reconnection.invoke<Boolean>('ConnectCircuit', circuitId)) {
-        throw "Failed to reconnect to the server";
-      }
+    circuitHandlers.forEach(h => h.onConnectionUp && h.onConnectionUp());
+  };
 
-      circuitHandlers.forEach(h => h.onConnectionUp());
-    };
+  circuitHandlers.forEach(h => h.onConnectionUp && h.onConnectionUp());
+}
 
-    circuitHandlers.forEach(h => h.onConnectionUp());
-  }
-
-  async function initializeConnection(): Promise<signalR.HubConnection> {
-    const connection = new signalR.HubConnectionBuilder()
-      .withUrl('_blazor')
-      .withHubProtocol(new MessagePackHubProtocol())
-      .configureLogging(signalR.LogLevel.Information)
-      .build();
-    connection.on('JS.BeginInvokeJS', DotNet.jsCallDispatcher.beginInvokeJSFromDotNet);
-    connection.on('JS.RenderBatch', (browserRendererId: number, renderId: number, batchData: Uint8Array) => {
-      try {
-        renderBatch(browserRendererId, new OutOfProcessRenderBatch(batchData));
-        connection.send('OnRenderCompleted', renderId, null);
-      }
-      catch (ex) {
-        // If there's a rendering exception, notify server *and* throw on client
-        connection.send('OnRenderCompleted', renderId, ex.toString());
-        throw ex;
-      }
-    });
-
-    connection.onclose(error => circuitHandlers.forEach(h => h.onConnectionDown(error)));
-    connection.on('JS.Error', unhandledError.bind(connection));
-
-    window['Blazor'].closeConnection = async() => {
-      await connection.stop();
-      DotNet.attachDispatcher({
-        beginInvokeDotNetFromJS: (...args) => {}});
-    }
+async function initializeConnection(circuitHandlers: CircuitHandler[]): Promise<signalR.HubConnection> {
+  const connection = new signalR.HubConnectionBuilder()
+    .withUrl('_blazor')
+    .withHubProtocol(new MessagePackHubProtocol())
+    .configureLogging(signalR.LogLevel.Information)
+    .build();
 
+  connection.on('JS.BeginInvokeJS', DotNet.jsCallDispatcher.beginInvokeJSFromDotNet);
+  connection.on('JS.RenderBatch', (browserRendererId: number, renderId: number, batchData: Uint8Array) => {
     try {
-      await connection.start();
+      renderBatch(browserRendererId, new OutOfProcessRenderBatch(batchData));
+      connection.send('OnRenderCompleted', renderId, null);
     } catch (ex) {
-      unhandledError.call(connection, ex);
+      // If there's a rendering exception, notify server *and* throw on client
+      connection.send('OnRenderCompleted', renderId, ex.toString());
+      throw ex;
     }
+  });
+
+  connection.onclose(error => circuitHandlers.forEach(h => h.onConnectionDown && h.onConnectionDown(error)));
+  connection.on('JS.Error', error => unhandledError(connection, error));
 
-    DotNet.attachDispatcher({
-      beginInvokeDotNetFromJS: (callId, assemblyName, methodIdentifier, dotNetObjectId, argsJson) => {
-        connection.send('BeginInvokeDotNetFromJS', callId ? callId.toString() : null, assemblyName, methodIdentifier, dotNetObjectId || 0, argsJson);
-      }
-    });
+  window['Blazor']._internal.forceCloseConnection = connection.stop;
 
-    return connection;
+  try {
+    await connection.start();
+  } catch (ex) {
+    unhandledError(connection, ex);
   }
 
-  function unhandledError(this: signalR.HubConnection, err) {
-    console.error(err);
-
-    // Disconnect on errors.
-    //
-    // TODO: it would be nice to have some kind of experience for what happens when you're
-    // trying to interact with an app that's disconnected.
-    //
-    // Trying to call methods on the connection after its been closed will throw.
-    if (this) {
-      this.stop();
+  DotNet.attachDispatcher({
+    beginInvokeDotNetFromJS: (callId, assemblyName, methodIdentifier, dotNetObjectId, argsJson) => {
+      connection.send('BeginInvokeDotNetFromJS', callId ? callId.toString() : null, assemblyName, methodIdentifier, dotNetObjectId || 0, argsJson);
     }
+  });
+
+  return connection;
+}
+
+function unhandledError(connection: signalR.HubConnection, err: Error) {
+  console.error(err);
+
+  // Disconnect on errors.
+  //
+  // Trying to call methods on the connection after its been closed will throw.
+  if (connection) {
+    connection.stop();
   }
 }
 

src/Components/Browser.JS/src/Platform/Circuits/CircuitHandler.ts

@@ -1,7 +1,10 @@
-export abstract class CircuitHandler {
-    onConnectionUp() : void{
-    }
+export interface CircuitHandler {
+    /** Invoked when a server connection is established or re-established after a connection failure.
+     */
+    onConnectionUp?() : void;
 
-    onConnectionDown(error?: Error): void{
-    }
+    /** Invoked when a server connection is dropped.
+     * @param {Error} error Optionally argument containing the error that caused the connection to close (if any).
+     */
+    onConnectionDown?(error?: Error): void;
 }