Revert "[browser] Clean-up typescript code imported from Blazor (#89435)"

src/mono/nuget/Microsoft.NET.Sdk.WebAssembly.Pack/build/Microsoft.NET.Sdk.WebAssembly.Browser.targets

@@ -372,8 +372,8 @@ Copyright (c) .NET Foundation. All rights reserved.
       RuntimeOptions="$(_BlazorWebAssemblyRuntimeOptions)"
       Extensions="@(WasmBootConfigExtension)"
       TargetFrameworkVersion="$(TargetFrameworkVersion)"
-      ModuleAfterConfigLoaded="@(WasmModuleAfterConfigLoaded)"
-      ModuleAfterRuntimeReady="@(WasmModuleAfterRuntimeReady)" />
+      LibraryInitializerOnRuntimeConfigLoaded="@(WasmLibraryInitializerOnRuntimeConfigLoaded)"
+      LibraryInitializerOnRuntimeReady="@(WasmLibraryInitializerOnRuntimeReady)" />
 
     <ItemGroup>
       <FileWrites Include="$(_WasmBuildBootJsonPath)" />
@@ -563,8 +563,8 @@ Copyright (c) .NET Foundation. All rights reserved.
       RuntimeOptions="$(_BlazorWebAssemblyRuntimeOptions)"
       Extensions="@(WasmBootConfigExtension)"
       TargetFrameworkVersion="$(TargetFrameworkVersion)"
-      ModuleAfterConfigLoaded="@(WasmModuleAfterConfigLoaded)"
-      ModuleAfterRuntimeReady="@(WasmModuleAfterRuntimeReady)" />
+      LibraryInitializerOnRuntimeConfigLoaded="@(WasmLibraryInitializerOnRuntimeConfigLoaded)"
+      LibraryInitializerOnRuntimeReady="@(WasmLibraryInitializerOnRuntimeReady)" />
 
     <ItemGroup>
       <FileWrites Include="$(IntermediateOutputPath)blazor.publish.boot.json" />

src/mono/wasm/Wasm.Build.Tests/ProjectProviderBase.cs

@@ -390,21 +390,15 @@ public void AssertBootJson(AssertBundleOptionsBase options)
         Assert.True(File.Exists(bootJsonPath), $"Expected to find {bootJsonPath}");
 
         BootJsonData bootJson = ParseBootData(bootJsonPath);
-        var bootJsonEntries = bootJson.resources.jsModuleNative.Keys
-            .Union(bootJson.resources.jsModuleRuntime.Keys)
-            .Union(bootJson.resources.jsModuleWorker?.Keys ?? Enumerable.Empty<string>())
-            .Union(bootJson.resources.jsSymbols?.Keys ?? Enumerable.Empty<string>())
-            .Union(bootJson.resources.wasmNative.Keys)
-            .ToArray();
+        var bootJsonEntries = bootJson.resources.runtime.Keys.Where(k => k.StartsWith("dotnet.", StringComparison.Ordinal)).ToArray();
 
         var expectedEntries = new SortedDictionary<string, Action<string>>();
         IReadOnlySet<string> expected = GetDotNetFilesExpectedSet(options);
 
         var knownSet = GetAllKnownDotnetFilesToFingerprintMap(options);
         foreach (string expectedFilename in expected)
         {
-            // FIXME: Find a systematic solution for skipping dotnet.js from boot json check
-            if (expectedFilename == "dotnet.js" || Path.GetExtension(expectedFilename) == ".map")
+            if (Path.GetExtension(expectedFilename) == ".map")
                 continue;
 
             bool expectFingerprint = knownSet[expectedFilename];

src/mono/wasm/runtime/dotnet.d.ts

@@ -95,6 +95,14 @@ interface DotnetHostBuilder {
     run(): Promise<number>;
 }
 type MonoConfig = {
+    /**
+     * The subfolder containing managed assemblies and pdbs. This is relative to dotnet.js script.
+     */
+    assemblyRootFolder?: string;
+    /**
+     * A list of assets to load along with the runtime.
+     */
+    assets?: AssetEntry[];
     /**
      * Additional search locations for assets.
      */
@@ -125,10 +133,6 @@ type MonoConfig = {
      * debugLevel < 0 enables debugging and disables debug logging.
      */
     debugLevel?: number;
-    /**
-     * Gets a value that determines whether to enable caching of the 'resources' inside a CacheStorage instance within the browser.
-     */
-    cacheBootResources?: boolean;
     /**
     * Enables diagnostic log messages during startup
     */
@@ -147,6 +151,10 @@ type MonoConfig = {
      * If true, the snapshot of runtime's memory will be stored in the browser and used for faster startup next time. Default is false.
      */
     startupMemoryCache?: boolean;
+    /**
+     * hash of assets
+     */
+    assetsHash?: string;
     /**
      * application environment
      */
@@ -159,10 +167,6 @@ type MonoConfig = {
      * definition of assets to load along with the runtime.
      */
     resources?: ResourceGroups;
-    /**
-     * appsettings files to load to VFS
-     */
-    appsettings?: string[];
     /**
      * config extensions declared in MSBuild items @(WasmBootConfigExtension)
      */
@@ -174,31 +178,26 @@ type ResourceExtensions = {
     [extensionName: string]: ResourceList;
 };
 interface ResourceGroups {
-    hash?: string;
-    assembly?: ResourceList;
-    lazyAssembly?: ResourceList;
-    pdb?: ResourceList;
-    jsModuleWorker?: ResourceList;
-    jsModuleNative: ResourceList;
-    jsModuleRuntime: ResourceList;
-    jsSymbols?: ResourceList;
-    wasmNative: ResourceList;
-    icu?: ResourceList;
-    satelliteResources?: {
+    readonly hash?: string;
+    readonly assembly?: ResourceList;
+    readonly lazyAssembly?: ResourceList;
+    readonly pdb?: ResourceList;
+    readonly runtime?: ResourceList;
+    readonly satelliteResources?: {
         [cultureName: string]: ResourceList;
     };
-    modulesAfterConfigLoaded?: ResourceList;
-    modulesAfterRuntimeReady?: ResourceList;
-    extensions?: ResourceExtensions;
-    vfs?: {
+    readonly libraryInitializers?: ResourceList;
+    readonly libraryStartupModules?: {
+        readonly onRuntimeConfigLoaded?: ResourceList;
+        readonly onRuntimeReady?: ResourceList;
+    };
+    readonly extensions?: ResourceExtensions;
+    readonly vfs?: {
         [virtualPath: string]: ResourceList;
     };
 }
-/**
- * A "key" is name of the file, a "value" is optional hash for integrity check.
- */
 type ResourceList = {
-    [name: string]: string | null | "";
+    [name: string]: string;
 };
 /**
  * Overrides the built-in boot resource loading mechanism so that boot resources can be fetched
@@ -209,12 +208,12 @@ type ResourceList = {
  * @param integrity The integrity string representing the expected content in the response.
  * @returns A URI string or a Response promise to override the loading process, or null/undefined to allow the default loading behavior.
  */
-type LoadBootResourceCallback = (type: AssetBehaviors | "manifest", name: string, defaultUri: string, integrity: string) => string | Promise<Response> | null | undefined;
+type LoadBootResourceCallback = (type: WebAssemblyBootResourceType, name: string, defaultUri: string, integrity: string) => string | Promise<Response> | null | undefined;
 interface ResourceRequest {
     name: string;
-    behavior: AssetBehaviors;
+    behavior: AssetBehaviours;
     resolvedUrl?: string;
-    hash?: string | null | "";
+    hash?: string;
 }
 interface LoadingResource {
     name: string;
@@ -249,24 +248,7 @@ interface AssetEntry extends ResourceRequest {
      */
     pendingDownload?: LoadingResource;
 }
-type SingleAssetBehaviors = 
-/**
- * The binary of the dotnet runtime.
- */
-"dotnetwasm"
-/**
- * The javascript module for threads.
- */
- | "js-module-threads"
-/**
- * The javascript module for threads.
- */
- | "js-module-runtime"
-/**
- * The javascript module for threads.
- */
- | "js-module-native";
-type AssetBehaviors = SingleAssetBehaviors | 
+type AssetBehaviours = 
 /**
  * Load asset as a managed resource assembly.
  */
@@ -291,6 +273,26 @@ type AssetBehaviors = SingleAssetBehaviors |
  * Load asset into the virtual filesystem (for fopen, File.Open, etc).
  */
  | "vfs"
+/**
+ * The binary of the dotnet runtime.
+ */
+ | "dotnetwasm"
+/**
+ * The javascript module for threads.
+ */
+ | "js-module-threads"
+/**
+ * The javascript module for threads.
+ */
+ | "js-module-runtime"
+/**
+ * The javascript module for threads.
+ */
+ | "js-module-dotnet"
+/**
+ * The javascript module for threads.
+ */
+ | "js-module-native"
 /**
  * The javascript module that came from nuget package .
  */
@@ -328,8 +330,10 @@ type DotnetModuleConfig = {
     onConfigLoaded?: (config: MonoConfig) => void | Promise<void>;
     onDotnetReady?: () => void | Promise<void>;
     onDownloadResourceProgress?: (resourcesLoaded: number, totalResources: number) => void;
+    getApplicationEnvironment?: (bootConfigResponse: Response) => string | null;
     imports?: any;
     exports?: string[];
+    downloadResource?: (request: ResourceRequest) => LoadingResource | undefined;
 } & Partial<EmscriptenModule>;
 type APIType = {
     runMain: (mainAssemblyName: string, args: string[]) => Promise<number>;
@@ -396,6 +400,7 @@ type ModuleAPI = {
     exit: (code: number, reason?: any) => void;
 };
 type CreateDotnetRuntimeType = (moduleFactory: DotnetModuleConfig | ((api: RuntimeAPI) => DotnetModuleConfig)) => Promise<RuntimeAPI>;
+type WebAssemblyBootResourceType = "assembly" | "pdb" | "dotnetjs" | "dotnetwasm" | "globalization" | "manifest" | "configuration";
 
 interface IDisposable {
     dispose(): void;

src/mono/wasm/runtime/lazyLoading.ts

@@ -1,50 +1,40 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-import { loaderHelpers, runtimeHelpers } from "./globals";
-import { AssetEntry } from "./types";
+import { INTERNAL, loaderHelpers, runtimeHelpers } from "./globals";
+import type { WebAssemblyResourceLoader } from "./loader/blazor/WebAssemblyResourceLoader";
 
 export async function loadLazyAssembly(assemblyNameToLoad: string): Promise<boolean> {
-    const resources = loaderHelpers.config.resources!;
+    const resourceLoader: WebAssemblyResourceLoader = INTERNAL.resourceLoader;
+    const resources = resourceLoader.bootConfig.resources;
     const lazyAssemblies = resources.lazyAssembly;
     if (!lazyAssemblies) {
         throw new Error("No assemblies have been marked as lazy-loadable. Use the 'BlazorWebAssemblyLazyLoad' item group in your project file to enable lazy loading an assembly.");
     }
 
-    if (!lazyAssemblies[assemblyNameToLoad]) {
+    const assemblyMarkedAsLazy = Object.prototype.hasOwnProperty.call(lazyAssemblies, assemblyNameToLoad);
+    if (!assemblyMarkedAsLazy) {
         throw new Error(`${assemblyNameToLoad} must be marked with 'BlazorWebAssemblyLazyLoad' item group in your project file to allow lazy-loading.`);
     }
 
-    const dllAsset: AssetEntry = {
-        name: assemblyNameToLoad,
-        hash: lazyAssemblies[assemblyNameToLoad],
-        behavior: "assembly",
-    };
-
     if (loaderHelpers.loadedAssemblies.some(f => f.includes(assemblyNameToLoad))) {
         return false;
     }
 
-    const pdbNameToLoad = changeExtension(dllAsset.name, ".pdb");
-    const shouldLoadPdb = loaderHelpers.hasDebuggingEnabled(loaderHelpers.config) && Object.prototype.hasOwnProperty.call(lazyAssemblies, pdbNameToLoad);
+    const dllNameToLoad = assemblyNameToLoad;
+    const pdbNameToLoad = changeExtension(assemblyNameToLoad, ".pdb");
+    const shouldLoadPdb = loaderHelpers.hasDebuggingEnabled(resourceLoader.bootConfig) && resources.pdb && Object.prototype.hasOwnProperty.call(lazyAssemblies, pdbNameToLoad);
 
-    const dllBytesPromise = loaderHelpers.retrieve_asset_download(dllAsset);
+    const dllBytesPromise = resourceLoader.loadResource(dllNameToLoad, loaderHelpers.locateFile(dllNameToLoad), lazyAssemblies[dllNameToLoad], "assembly").response.then(response => response.arrayBuffer());
 
     let dll = null;
     let pdb = null;
     if (shouldLoadPdb) {
-        const pdbBytesPromise = lazyAssemblies[pdbNameToLoad]
-            ? loaderHelpers.retrieve_asset_download({
-                name: pdbNameToLoad,
-                hash: lazyAssemblies[pdbNameToLoad],
-                behavior: "pdb"
-            })
-            : Promise.resolve(null);
-
+        const pdbBytesPromise = await resourceLoader.loadResource(pdbNameToLoad, loaderHelpers.locateFile(pdbNameToLoad), lazyAssemblies[pdbNameToLoad], "pdb").response.then(response => response.arrayBuffer());
         const [dllBytes, pdbBytes] = await Promise.all([dllBytesPromise, pdbBytesPromise]);
 
         dll = new Uint8Array(dllBytes);
-        pdb = pdbBytes ? new Uint8Array(pdbBytes) : null;
+        pdb = new Uint8Array(pdbBytes);
     } else {
         const dllBytes = await dllBytesPromise;
         dll = new Uint8Array(dllBytes);