From 1df8fe258ecfadbed48673c1620cf8117f1837eb Mon Sep 17 00:00:00 2001
From: schlagmichdoch <schlagmichdoch@users.noreply.github.com>
Date: Tue, 13 Feb 2024 18:23:27 +0100
Subject: [PATCH] Tidy up zipper functions

---
 public/scripts/ui.js   | 57 ++++++++++++++++-----------------------
 public/scripts/util.js | 60 ++++++++++++++++++++++++------------------
 2 files changed, 56 insertions(+), 61 deletions(-)

diff --git a/public/scripts/ui.js b/public/scripts/ui.js
index 617dcb2..c02537c 100644
--- a/public/scripts/ui.js
+++ b/public/scripts/ui.js
@@ -1231,23 +1231,31 @@ class ReceiveFileDialog extends ReceiveDialog {
     }
 
     async _processDataAsZip() {
-        let zipFileUrl, zipFileName;
+        let zipObjectUrl = "";
+        let zipName = "";
         let sendAsZip = false;
 
         const tooBigToZip = window.iOS && this._data.totalSize > 256000000;
-        if (this._data.files.length > 1 && !tooBigToZip) {
-            zipFileUrl = await this._createZipFile(this._data.files, zipProgress => {
-                Events.fire('set-progress', {
-                    peerId: this._data.peerId,
-                    progress: zipProgress / this._data.totalSize,
-                    status: 'process'
-                })
-            });
-            zipFileName = this._createZipFilename()
 
-            sendAsZip = !!zipFileUrl;
+        if (this._data.files.length > 1 && !tooBigToZip) {
+            Events.fire('set-progress', {
+                peerId: this._data.peerId,
+                progress: 0,
+                status: 'process'
+            });
+
+            zipObjectUrl = await zipper.getObjectUrlOfZipFile(this._data.files,zipProgress => {
+                    Events.fire('set-progress', {
+                        peerId: this._data.peerId,
+                        progress: zipProgress / this._data.totalSize,
+                        status: 'process'
+                    });
+                });
+            zipName = this._createZipFilename();
+
+            sendAsZip = !!zipObjectUrl;
         }
-        return {sendAsZip, zipFileUrl, zipFileName};
+        return {sendAsZip, zipObjectUrl, zipName};
     }
 
     _setDownloadButtonToZip(zipFileUrl, zipFileName) {
@@ -1318,27 +1326,6 @@ class ReceiveFileDialog extends ReceiveDialog {
         }
     }
 
-    async _createZipFile(files, onProgressCallback) {
-        try {
-            let bytesCompleted = 0;
-
-            zipper.createNewZipWriter();
-
-            for (let i = 0; i < files.length; i++) {
-                await zipper.addFile(files[i], {
-                    onprogress: (progress) => onProgressCallback(bytesCompleted + progress)
-                });
-                bytesCompleted += files[i].size;
-            }
-
-            return await zipper.getBlobURL();
-        }
-        catch (e) {
-            Logger.error(e);
-            return false;
-        }
-    }
-
     _createZipFilename() {
         let now = new Date(Date.now());
         let year = now.getFullYear().toString();
@@ -1373,11 +1360,11 @@ class ReceiveFileDialog extends ReceiveDialog {
         this.$downloadBtn.removeAttribute('disabled');
         this.$downloadBtn.removeAttribute('hidden');
 
-        let {sendAsZip, zipFileUrl, zipFileName} = await this._processDataAsZip();
+        let {sendAsZip, zipObjectUrl, zipName} = await this._processDataAsZip();
 
         // If single file or zipping failed -> download files individually -> else download zip
         if (sendAsZip) {
-            this._setDownloadButtonToZip(zipFileUrl, zipFileName);
+            this._setDownloadButtonToZip(zipObjectUrl, zipName);
         } else {
             this._setDownloadButtonToFiles(this._data.files);
         }
diff --git a/public/scripts/util.js b/public/scripts/util.js
index 7a1a549..6f666bf 100644
--- a/public/scripts/util.js
+++ b/public/scripts/util.js
@@ -82,39 +82,47 @@ const audioPlayer = (() => {
 
 const zipper = (() => {
 
-    let zipWriter;
     return {
-        createNewZipWriter() {
-            zipWriter = new zip.ZipWriter(new zip.BlobWriter("application/zip"), { bufferedWrite: true, level: 0 });
-        },
-        addFile(file, options) {
-            return zipWriter.add(file.name, new zip.BlobReader(file), options);
-        },
-        async getBlobURL() {
-            if (zipWriter) {
-                const blobURL = URL.createObjectURL(await zipWriter.close());
-                zipWriter = null;
-                return blobURL;
+        async getObjectUrlOfZipFile(files, onZipProgressCallback){
+            try {
+                const zipWriter = new zip.ZipWriter(new zip.BlobWriter("application/zip"));
+
+                let bytesProcessed = 0;
+                for (let i = 0; i < files.length; i++) {
+                    await zipWriter.add(
+                        files[i].name,
+                        new zip.BlobReader(files[i]),
+                        {
+                            onprogress: (progress) => onZipProgressCallback(bytesProcessed + progress)
+                        }
+                    );
+                    bytesProcessed += files[i].size;
+                }
+
+                return URL.createObjectURL(await zipWriter.close());
             }
-            else {
-                throw new Error("Zip file closed");
-            }
-        },
-        async getZipFile(filename = "archive.zip") {
-            if (zipWriter) {
-                const file = new File([await zipWriter.close()], filename, {type: "application/zip"});
-                zipWriter = null;
-                return file;
-            }
-            else {
-                throw new Error("Zip file closed");
+            catch (e) {
+                Logger.error(e);
+                return false;
             }
         },
         async getEntries(file, options) {
-            return await (new zip.ZipReader(new zip.BlobReader(file))).getEntries(options);
+            try {
+                return await (new zip.ZipReader(new zip.BlobReader(file))).getEntries(options);
+            }
+            catch (e) {
+                Logger.error(e);
+                return false;
+            }
         },
         async getData(entry, options) {
-            return await entry.getData(new zip.BlobWriter(), options);
+            try {
+                return await entry.getData(new zip.BlobWriter(), options);
+            }
+            catch (e) {
+                Logger.error(e);
+                return false;
+            }
         },
     };