@sparkvault/sdk 1.10.0 → 1.10.2

package/dist/sparkvault.esm.js

@@ -7049,12 +7049,20 @@ class UploadModalContainer {
             this.elements.modal.classList.add('svu-with-sidebar');
             this.elements.modal.appendChild(sidebar);
             this.elements.sidebar = sidebar;
+            // Hide header when sidebar is shown (sidebar has its own logo)
+            if (this.headerElement) {
+                this.headerElement.style.display = 'none';
+            }
         }
         else if (!show && this.elements.sidebar) {
             // Remove sidebar
             this.elements.modal.classList.remove('svu-with-sidebar');
             this.elements.sidebar.remove();
             this.elements.sidebar = null;
+            // Show header again when sidebar is hidden
+            if (this.headerElement) {
+                this.headerElement.style.display = '';
+            }
         }
     }
     createSecuritySidebar() {
@@ -8180,48 +8188,66 @@ class UploadRenderer {
         }
         // Build full upload URL
         const uploadUrl = location.startsWith('http') ? location : `${url.origin}${location}`;
-        // Step 2: Upload file in chunks
+        // Step 2: Upload file in chunks with progress tracking
         let offset = 0;
         const totalSize = file.size;
         while (offset < totalSize) {
-            const end = Math.min(offset + chunkSize, totalSize);
-            const chunk = file.slice(offset, end);
-            // Upload chunk
-            const patchResponse = await fetch(uploadUrl, {
-                method: 'PATCH',
-                headers: {
-                    'Tus-Resumable': TUS_VERSION,
-                    'Upload-Offset': String(offset),
-                    'Content-Type': 'application/offset+octet-stream',
-                },
-                body: chunk,
-            });
-            if (!patchResponse.ok) {
-                const errorText = await patchResponse.text();
-                throw new Error(`Chunk upload failed: ${patchResponse.status} ${errorText}`);
-            }
-            // Update offset from server response
-            const newOffsetHeader = patchResponse.headers.get('Upload-Offset');
-            const newOffset = newOffsetHeader ? parseInt(newOffsetHeader, 10) : end;
+            const chunkStart = offset;
+            const chunkEnd = Math.min(offset + chunkSize, totalSize);
+            const chunk = file.slice(chunkStart, chunkEnd);
+            // Upload chunk with XHR for progress events
+            const newOffset = await this.uploadChunkWithProgress(uploadUrl, chunk, chunkStart, totalSize, TUS_VERSION, file, ingotId, requestId);
             offset = newOffset;
-            // Update progress
-            const progress = Math.round((offset / totalSize) * 100);
-            this.setState({
-                view: 'uploading',
-                file,
-                ingotId,
-                requestId,
-                progress,
-                bytesUploaded: offset,
-            });
-            this.callbacks.onProgress?.({
-                bytesUploaded: offset,
-                bytesTotal: totalSize,
-                percentage: progress,
-                phase: 'uploading',
-            });
         }
     }
+    /**
+     * Upload a single chunk using XMLHttpRequest for progress tracking
+     */
+    uploadChunkWithProgress(uploadUrl, chunk, chunkStart, totalSize, tusVersion, file, ingotId, requestId) {
+        return new Promise((resolve, reject) => {
+            const xhr = new XMLHttpRequest();
+            // Track progress within this chunk
+            xhr.upload.onprogress = (e) => {
+                if (e.lengthComputable) {
+                    // Calculate total progress: completed chunks + progress within current chunk
+                    const totalUploaded = chunkStart + e.loaded;
+                    const progress = Math.round((totalUploaded / totalSize) * 100);
+                    this.setState({
+                        view: 'uploading',
+                        file,
+                        ingotId,
+                        requestId,
+                        progress,
+                        bytesUploaded: totalUploaded,
+                    });
+                    this.callbacks.onProgress?.({
+                        bytesUploaded: totalUploaded,
+                        bytesTotal: totalSize,
+                        percentage: progress,
+                        phase: 'uploading',
+                    });
+                }
+            };
+            xhr.onload = () => {
+                if (xhr.status >= 200 && xhr.status < 300) {
+                    // Get new offset from server response
+                    const newOffsetHeader = xhr.getResponseHeader('Upload-Offset');
+                    const newOffset = newOffsetHeader ? parseInt(newOffsetHeader, 10) : chunkStart + chunk.size;
+                    resolve(newOffset);
+                }
+                else {
+                    reject(new Error(`Chunk upload failed with status ${xhr.status}`));
+                }
+            };
+            xhr.onerror = () => reject(new Error('Chunk upload failed'));
+            xhr.ontimeout = () => reject(new Error('Chunk upload timed out'));
+            xhr.open('PATCH', uploadUrl);
+            xhr.setRequestHeader('Tus-Resumable', tusVersion);
+            xhr.setRequestHeader('Upload-Offset', String(chunkStart));
+            xhr.setRequestHeader('Content-Type', 'application/offset+octet-stream');
+            xhr.send(chunk);
+        });
+    }
     async runCeremony(file, ingotId, requestId) {
         for (let i = 0; i < CEREMONY_STEPS.length; i++) {
             this.setState({