[browser][coreCLR] fix streaming instatiation for NodeJS

src/native/corehost/browserhost/loader/assets.ts

@@ -7,7 +7,7 @@ import { dotnetAssert, dotnetLogger, dotnetInternals, dotnetBrowserHostExports,
 import { ENVIRONMENT_IS_WEB, ENVIRONMENT_IS_SHELL, ENVIRONMENT_IS_NODE } from "./per-module";
 import { createPromiseCompletionSource, delay } from "./promise-completion-source";
 import { locateFile, makeURLAbsoluteWithApplicationBase } from "./bootstrap";
-import { fetchLike } from "./polyfills";
+import { fetchLike, responseLike } from "./polyfills";
 import { loaderConfig } from "./config";
 
 let throttlingPCS: PromiseCompletionSource<void> | undefined;
@@ -264,22 +264,17 @@ async function loadResourceThrottle(asset: AssetEntryInternal): Promise<Response
 }
 
 async function loadResourceFetch(asset: AssetEntryInternal): Promise<Response> {
+    const expectedContentType = asset.behavior === "dotnetwasm" ? "application/wasm" : "application/octet-stream";
     if (asset.buffer) {
-        return <Response><any>{
-            ok: true,
+        const arrayBuffer = await asset.buffer;
+        return responseLike(asset.resolvedUrl!, arrayBuffer, {
+            status: 200,
+            statusText: "OK",
             headers: {
-                length: 0,
-                get: () => null
-            },
-            url: asset.resolvedUrl,
-            arrayBuffer: () => Promise.resolve(asset.buffer!),
-            json: () => {
-                throw new Error("NotImplementedException");
-            },
-            text: () => {
-                throw new Error("NotImplementedException");
+                "Content-Length": arrayBuffer.byteLength.toString(),
+                "Content-Type": expectedContentType,
             }
-        };
+        });
     }
     if (asset.pendingDownload) {
         return asset.pendingDownload.response;
@@ -317,7 +312,7 @@ async function loadResourceFetch(asset: AssetEntryInternal): Promise<Response> {
         }
     }
 
-    return fetchLike(asset.resolvedUrl!, fetchOptions);
+    return fetchLike(asset.resolvedUrl!, fetchOptions, expectedContentType);
 }
 
 function onDownloadedAsset() {

src/native/corehost/browserhost/loader/polyfills.ts

@@ -69,7 +69,7 @@ export async function nodeUrl(): Promise<any> {
     return _nodeUrl;
 }
 
-export async function fetchLike(url: string, init?: RequestInit): Promise<Response> {
+export async function fetchLike(url: string, init?: RequestInit, expectedContentType?: string): Promise<Response> {
     try {
         await nodeFs();
         await nodeUrl();
@@ -85,60 +85,53 @@ export async function fetchLike(url: string, init?: RequestInit): Promise<Respon
             }
 
             const arrayBuffer = await _nodeFs.promises.readFile(url);
-            return <Response><any>{
-                ok: true,
+            return responseLike(url, arrayBuffer, {
+                status: 200,
+                statusText: "OK",
                 headers: {
-                    length: 0,
-                    get: () => null
-                },
-                url,
-                arrayBuffer: () => arrayBuffer,
-                json: () => {
-                    throw new Error("NotImplementedException");
-                },
-                text: () => {
-                    throw new Error("NotImplementedException");
+                    "Content-Length": arrayBuffer.byteLength.toString(),
+                    "Content-Type": expectedContentType || "application/octet-stream"
                 }
-            };
+            });
         } else if (hasFetch) {
             return globalThis.fetch(url, init || { credentials: "same-origin" });
         } else if (typeof (read) === "function") {
-            return <Response><any>{
-                ok: true,
-                url,
+            const arrayBuffer = read(url, "binary");
+            return responseLike(url, arrayBuffer, {
+                status: 200,
+                statusText: "OK",
                 headers: {
-                    length: 0,
-                    get: () => null
-                },
-                arrayBuffer: () => {
-                    return new Uint8Array(read(url, "binary"));
-                },
-                json: () => {
-                    return JSON.parse(read(url, "utf8"));
-                },
-                text: () => read(url, "utf8")
-            };
+                    "Content-Length": arrayBuffer.byteLength.toString(),
+                    "Content-Type": expectedContentType || "application/octet-stream"
+                }
+            });
         }
     } catch (e: any) {
-        return <Response><any>{
-            ok: false,
-            url,
+        return responseLike(url, null, {
             status: 500,
-            headers: {
-                length: 0,
-                get: () => null
-            },
             statusText: "ERR28: " + e,
-            arrayBuffer: () => {
-                throw e;
-            },
-            json: () => {
-                throw e;
-            },
-            text: () => {
-                throw e;
-            }
-        };
+        });
     }
     throw new Error("No fetch implementation available");
 }
+
+export function responseLike(url: string, body: ArrayBuffer | null, options: ResponseInit): Response {
+    if (typeof globalThis.Response === "function") {
+        return new Response(body, options);
+    }
+    return <Response><any>{
+        ok: body !== null && options.status == 200,
+        headers: {
+            ...options.headers,
+            get: () => null
+        },
+        url,
+        arrayBuffer: () => Promise.resolve(body),
+        json: () => {
+            throw new Error("NotImplementedException");
+        },
+        text: () => {
+            throw new Error("NotImplementedException");
+        }
+    };
+}