Add support for configuration (#19544)

* Add support for configuration

Fixes #18675

Author: pranavkm

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

@@ -4,10 +4,12 @@ import * as Environment from './Environment';
 import { monoPlatform } from './Platform/Mono/MonoPlatform';
 import { renderBatch } from './Rendering/Renderer';
 import { SharedMemoryRenderBatch } from './Rendering/RenderBatch/SharedMemoryRenderBatch';
-import { Pointer } from './Platform/Platform';
 import { shouldAutoStart } from './BootCommon';
 import { setEventDispatcher } from './Rendering/RendererEventDispatcher';
 import { WebAssemblyResourceLoader } from './Platform/WebAssemblyResourceLoader';
+import { WebAssemblyConfigLoader } from './Platform/WebAssemblyConfigLoader';
+import { BootConfigResult } from './Platform/BootConfig';
+import { Pointer } from './Platform/Platform';
 
 let started = false;
 
@@ -38,7 +40,12 @@ async function boot(options?: any): Promise<void> {
   });
 
   // Fetch the resources and prepare the Mono runtime
-  const resourceLoader = await WebAssemblyResourceLoader.initAsync();
+  const bootConfigResult = await BootConfigResult.initAsync();
+
+  const [resourceLoader] = await Promise.all([
+    WebAssemblyResourceLoader.initAsync(bootConfigResult.bootConfig),
+    WebAssemblyConfigLoader.initAsync(bootConfigResult)]);
+
   try {
     await platform.start(resourceLoader);
   } catch (ex) {

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

@@ -0,0 +1,38 @@
+export class BootConfigResult {
+  private constructor(public bootConfig: BootJsonData, public applicationEnvironment: string) {
+  }
+
+  static async initAsync(): Promise<BootConfigResult> {
+    const bootConfigResponse = await fetch('_framework/blazor.boot.json', {
+      method: 'GET',
+      credentials: 'include',
+      cache: 'no-cache'
+    });
+
+    // While we can expect an ASP.NET Core hosted application to include the environment, other
+    // hosts may not. Assume 'Production' in the absenc of any specified value.
+    const applicationEnvironment = bootConfigResponse.headers.get('Blazor-Environment') || 'Production';
+    const bootConfig: BootJsonData = await bootConfigResponse.json();
+
+    return new BootConfigResult(bootConfig, applicationEnvironment);
+  };
+}
+
+// Keep in sync with bootJsonData in Microsoft.AspNetCore.Components.WebAssembly.Build
+export interface BootJsonData {
+  readonly entryAssembly: string;
+  readonly resources: ResourceGroups;
+  readonly debugBuild: boolean;
+  readonly linkerEnabled: boolean;
+  readonly cacheBootResources: boolean;
+  readonly config: string[];
+}
+
+export interface ResourceGroups {
+  readonly assembly: ResourceList;
+  readonly pdb?: ResourceList;
+  readonly runtime: ResourceList;
+}
+
+export type ResourceList = { [name: string]: string };
+

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

@@ -1,9 +1,9 @@
-import { System_Object, System_String, System_Array, Pointer, Platform } from '../Platform';
 import { attachDebuggerHotkey, hasDebuggingEnabled } from './MonoDebugger';
 import { showErrorNotification } from '../../BootErrors';
 import { WebAssemblyResourceLoader, LoadingResource } from '../WebAssemblyResourceLoader';
+import { Platform, System_Array, Pointer, System_Object, System_String } from '../Platform';
 
-let mono_string_get_utf8: (managedString: System_String) => Mono.Utf8Ptr;
+let mono_string_get_utf8: (managedString: System_String) => Pointer;
 let mono_wasm_add_assembly: (name: string, heapAddress: number, length: number) => void;
 const appBinDirName = 'appBinDir';
 const uint64HighOrderShift = Math.pow(2, 32);
@@ -47,7 +47,7 @@ export const monoPlatform: Platform = {
     // FIXME this is unsafe, cuz raw objects could be GC'd.
 
     const utf8 = mono_string_get_utf8(managedString);
-    const res = Module.UTF8ToString(utf8);
+    const res = (<any>window['Module']).UTF8ToString(utf8);
     Module._free(utf8 as any);
     return res;
   },
@@ -168,7 +168,7 @@ function createEmscriptenModuleInstance(resourceLoader: WebAssemblyResourceLoade
   };
   module.preRun = [];
   module.postRun = [];
-  module.preloadPlugins = [];
+  (module as any).preloadPlugins = [];
 
   // Override the mechanism for fetching the main wasm file so we can connect it to our cache
   module.instantiateWasm = (imports, successCallback): WebAssembly.Exports => {
@@ -258,10 +258,10 @@ function getArrayDataPointer<T>(array: System_Array<T>): number {
   return <number><any>array + 12; // First byte from here is length, then following bytes are entries
 }
 
-function bindStaticMethod(assembly: string, typeName: string, method: string) : (...args: any[]) => any {
+function bindStaticMethod(assembly: string, typeName: string, method: string) {
   // Fully qualified name looks like this: "[debugger-test] Math:IntAdd"
   const fqn = `[${assembly}] ${typeName}:${method}`;
-  return Module.mono_bind_static_method(fqn);
+  return BINDING.bind_static_method(fqn);
 }
 
 function attachInteropInvoker(): void {

src/Components/Web.JS/src/Platform/BootConfig.ts

@@ -0,0 +1,23 @@
+import { Pointer, System_String } from '../Platform';
+
+// Mono uses this global to hang various debugging-related items on
+
+declare interface MONO {
+  loaded_files: string[];
+  mono_wasm_runtime_ready (): void;
+  mono_wasm_setenv (name: string, value: string): void;
+}
+
+// Mono uses this global to hold low-level interop APIs
+declare interface BINDING {
+  js_string_to_mono_string(jsString: string): System_String;
+  js_typed_array_to_array(array: Uint8Array): Pointer;
+  js_typed_array_to_array<T>(array: Array<T>): Pointer;
+  conv_string(dotnetString: System_String | null): string | null;
+  bind_static_method(fqn: string, signature?: string): Function;
+}
+
+declare global {
+  var MONO: MONO;
+  var BINDING: BINDING;
+}

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

@@ -1,4 +1,4 @@
-import { WebAssemblyResourceLoader } from "./WebAssemblyResourceLoader";
+import { WebAssemblyResourceLoader } from './WebAssemblyResourceLoader';
 
 export interface Platform {
   start(resourceLoader: WebAssemblyResourceLoader): Promise<void>;

src/Components/Web.JS/src/Platform/Mono/MonoTypes.d.ts

@@ -0,0 +1,28 @@
+import { BootConfigResult } from './BootConfig';
+import { System_String, Pointer } from './Platform';
+
+export class WebAssemblyConfigLoader {
+  static async initAsync(bootConfigResult: BootConfigResult): Promise<void> {
+    window['Blazor']._internal.getApplicationEnvironment = () => BINDING.js_string_to_mono_string(bootConfigResult.applicationEnvironment);
+
+    const configFiles = await Promise.all((bootConfigResult.bootConfig.config || [])
+      .filter(name => name === 'appsettings.json' || name === `appsettings.${bootConfigResult.applicationEnvironment}.json`)
+      .map(async name => ({ name, content: await getConfigBytes(name) })));
+
+    window['Blazor']._internal.getConfig = (dotNetFileName: System_String) : Pointer | undefined => {
+      const fileName = BINDING.conv_string(dotNetFileName);
+      const resolvedFile = configFiles.find(f => f.name === fileName);
+      return resolvedFile ? BINDING.js_typed_array_to_array(resolvedFile.content) : undefined;
+    };
+
+    async function getConfigBytes(file: string): Promise<Uint8Array> {
+      const response = await fetch(file, {
+        method: 'GET',
+        credentials: 'include',
+        cache: 'no-cache'
+      });
+
+      return new Uint8Array(await response.arrayBuffer());
+    }
+  }
+}

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

@@ -1,25 +1,18 @@
 import { toAbsoluteUri } from '../Services/NavigationManager';
+import { BootJsonData, ResourceList } from './BootConfig';
 const networkFetchCacheMode = 'no-cache';
 
 export class WebAssemblyResourceLoader {
   private usedCacheKeys: { [key: string]: boolean } = {};
   private networkLoads: { [name: string]: LoadLogEntry } = {};
   private cacheLoads: { [name: string]: LoadLogEntry } = {};
 
-  static async initAsync(): Promise<WebAssemblyResourceLoader> {
-    const bootConfigResponse = await fetch('_framework/blazor.boot.json', {
-      method: 'GET',
-      credentials: 'include',
-      cache: networkFetchCacheMode
-    });
-    const bootConfig: BootJsonData = await bootConfigResponse.json();
+  static async initAsync(bootConfig: BootJsonData): Promise<WebAssemblyResourceLoader> {
     const cache = await getCacheToUseIfEnabled(bootConfig);
-
     return new WebAssemblyResourceLoader(bootConfig, cache);
   }
 
-  constructor (public readonly bootConfig: BootJsonData, private cacheIfUsed: Cache | null)
-  {
+  constructor(readonly bootConfig: BootJsonData, readonly cacheIfUsed: Cache | null) {
   }
 
   loadResources(resources: ResourceList, url: (name: string) => string): LoadingResource[] {
@@ -36,7 +29,7 @@ export class WebAssemblyResourceLoader {
       ? this.loadResourceWithCaching(this.cacheIfUsed, name, url, contentHash)
       : fetch(url, { cache: networkFetchCacheMode, integrity: this.bootConfig.cacheBootResources ? contentHash : undefined });
 
-      return { name, url, response };
+    return { name, url, response };
   }
 
   logToConsole() {
@@ -166,7 +159,7 @@ function countTotalBytes(loads: LoadLogEntry[]) {
 }
 
 function toDataSizeString(byteCount: number) {
-  return `${(byteCount / (1024*1024)).toFixed(2)} MB`;
+  return `${(byteCount / (1024 * 1024)).toFixed(2)} MB`;
 }
 
 function getPerformanceEntry(url: string): PerformanceResourceTiming | undefined {
@@ -175,21 +168,6 @@ function getPerformanceEntry(url: string): PerformanceResourceTiming | undefined
   }
 }
 
-// Keep in sync with bootJsonData in Microsoft.AspNetCore.Blazor.Build
-interface BootJsonData {
-  readonly entryAssembly: string;
-  readonly resources: ResourceGroups;
-  readonly debugBuild: boolean;
-  readonly linkerEnabled: boolean;
-  readonly cacheBootResources: boolean;
-}
-
-interface ResourceGroups {
-  readonly assembly: ResourceList;
-  readonly pdb?: ResourceList;
-  readonly runtime: ResourceList;
-}
-
 interface LoadLogEntry {
   responseBytes: number | undefined;
 }
@@ -199,5 +177,3 @@ export interface LoadingResource {
   url: string;
   response: Promise<Response>;
 }
-
-type ResourceList = { [name: string]: string };