Updated mooncore dependencies

Moonlight.Client/wwwroot/js/downloadService.js

@@ -1,13 +1,46 @@
 window.moonCoreDownloadService = {
-    download: async function (fileName, contentStreamReference) {
-        const arrayBuffer = await contentStreamReference.arrayBuffer();
-        const blob = new Blob([arrayBuffer]);
+    download: async function (fileName, contentStreamReference, id, reportRef) {
+
+        const stream = await contentStreamReference.stream();
+        const reader = stream.getReader();
+
+        let lastReportTime = 0;
+        let receivedLength = 0; // Track downloaded size
+        let chunks = []; // Store downloaded chunks
+
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+
+            chunks.push(value);
+            receivedLength += value.length;
+
+            if(reportRef)
+            {
+                const now = Date.now();
+
+                if (now - lastReportTime >= 500) { // Only log once per second
+                    await reportRef.invokeMethodAsync("ReceiveReport", id, receivedLength, false);
+                    lastReportTime = now;
+                }
+            }
+        }
+
+        // Combine chunks into a single Blob
+        const blob = new Blob(chunks);
         const url = URL.createObjectURL(blob);
-        const anchorElement = document.createElement('a');
-        anchorElement.href = url;
-        anchorElement.download = fileName ?? '';
-        anchorElement.click();
-        anchorElement.remove();
+
+        // Trigger file download
+        const anchor = document.createElement("a");
+        anchor.href = url;
+        anchor.download = fileName;
+        document.body.appendChild(anchor);
+        anchor.click();
+
+        document.body.removeChild(anchor);
         URL.revokeObjectURL(url);
+
+        if(reportRef)
+            await reportRef.invokeMethodAsync("ReceiveReport", id, receivedLength, true);
     }
 }

Moonlight.Client/wwwroot/js/fileManager.js

@@ -1,26 +1,82 @@
 window.moonCoreFileManager = {
     uploadCache: [],
+    addFilesToCache: async function(id) {
+        let files = document.getElementById(id).files;
+
+
+        for (let i = 0; i < files.length; i++) {
+            this.uploadCache.push(files[i]);
+        }
+
+        await this.ref.invokeMethodAsync("TriggerUpload", this.uploadCache.length);
+    },
+    getNextFromCache: async function() {
+        if(this.uploadCache.length === 0)
+            return null;
+
+        let nextItem = this.uploadCache.pop();
+
+        if(!nextItem)
+            return null;
+
+        let file;
+        let path;
+
+        if(nextItem instanceof File)
+        {
+            file = nextItem;
+            path = file.name;
+        }
+        else
+        {
+            file = await this.openFileEntry(nextItem);
+            path = nextItem.fullPath;
+        }
+
+        if(file.size === 0)
+        {
+            return {
+                path: null,
+                stream: null,
+                left: this.uploadCache.length
+            }
+        }
+
+        let stream = await this.createStreamRef(file);
+
+        return {
+            path: path,
+            stream: stream,
+            left: this.uploadCache.length
+        };
+    },
     readCache: async function (index) {
-        const item = this.uploadCache.at(index);
-        const streamRef = await this.createStreamRef(item);
+        const item = this.uploadCache.pop();
+        console.log(item);
+        const streamRefData = await this.createStreamRef(item);
+
+        if(streamRefData == null)
+            return {path: item.fullPath, streamRef: null};
 
         return {
             path: item.fullPath,
-            streamRef: streamRef
+            streamRef: streamRefData.stream,
+            size: streamRefData.size
         };
     },
-    createStreamRef: async function (fileEntry) {
+    openFileEntry: async function (fileEntry) {
         const promise = new Promise(resolve => {
             fileEntry.file(file => {
                 resolve(file);
             }, err => console.log(err));
         });
 
-        const processedFile = await promise;
-
+        return await promise;
+    },
+    createStreamRef: async function (processedFile) {
         // Prevent uploads of empty files
         if (processedFile.size <= 0) {
-            console.log("Skipping upload of '" + fileEntry.fullPath + "' as its empty");
+            console.log("Skipping upload of '" + processedFile.name + "' as its empty");
             return null;
         }
 
@@ -39,6 +95,8 @@ window.moonCoreFileManager = {
         return DotNet.createJSStreamReference(arrayBuffer);
     },
     setup: function (id, callbackRef) {
+        this.ref = callbackRef;
+
         // Check which features are supported by the browser
         const supportsFileSystemAccessAPI =
             'getAsFileSystemHandle' in DataTransferItem.prototype;
@@ -64,8 +122,8 @@ window.moonCoreFileManager = {
             }
 
             this.getAllWebkitFileEntries(e.dataTransfer.items).then(async value => {
-                this.uploadCache = value;
-                await callbackRef.invokeMethodAsync("OnFilesDropped", this.uploadCache.length);
+                value.forEach(a => this.uploadCache.push(a));
+                await this.ref.invokeMethodAsync("TriggerUpload", this.uploadCache.length);
             });
         });
     },