vndangkhoa/kv-music
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Revert "Feat: Implement memory-efficient sequential streaming ZIP downloads using zip.js and StreamSaver.js"

Browse source 
This reverts commit 67a97a34a8.
This commit is contained in:
Julien Maille 2026-01-07 23:32:49 +01:00
parent fc53295ced
commit b3437dc99a
1 changed files with 107 additions and 107 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

214
js/downloads.js
View file

@ -6,24 +6,24 @@ import { addMetadataToAudio } from './metadata.js';
const downloadTasks = new Map();
let downloadNotificationContainer = null;
async function loadZipJS() {
try {
// Load zip.js from CDN (ES Module)
const module = await import('https://cdn.jsdelivr.net/npm/@zip.js/zip.js@2.7.34/index.js');
return module;
} catch (error) {
console.error('Failed to load zip.js:', error);
throw new Error('Failed to load ZIP library');
/**
* Adds a cover blob to a JSZip instance
*/
function addCoverBlobToZip(zip, folderPath, blob) {
if (!blob) return;
const path = folderPath ? `${folderPath}/cover.jpg` : 'cover.jpg';
if (!zip.file(path)) {
zip.file(path, blob);
}
}
async function loadStreamSaver() {
async function loadJSZip() {
try {
const module = await import('https://cdn.jsdelivr.net/npm/streamsaver@2.0.6/StreamSaver.js');
const module = await import('https://cdn.jsdelivr.net/npm/jszip@3.10.1/+esm');
return module.default;
} catch (error) {
console.error('Failed to load StreamSaver:', error);
throw new Error('Failed to load StreamSaver library');
console.error('Failed to load JSZip:', error);
throw new Error('Failed to load ZIP library');
}
}
@ -167,7 +167,7 @@ function removeDownloadTask(trackId) {
}, 300);
}
async function downloadTrackBlob(track, quality, api) {
async function downloadTrackBlob(track, quality, api, lyricsManager = null) {
const lookup = await api.getTrack(track.id, quality);
let streamUrl;
@ -193,49 +193,81 @@ async function downloadTrackBlob(track, quality, api) {
return blob;
}
/**
* Initializes the download stream (using File System Access API or StreamSaver)
* and returns a ZipWriter instance that pipes to it.
*/
async function createZipStreamWriter(filename) {
const zip = await loadZipJS();
let writable;
let abortFn = null;
async function generateAndDownloadZip(zip, filename, notification, progressTotal, fileHandle = null) {
updateBulkDownloadProgress(notification, progressTotal, progressTotal, 'Creating ZIP...');
// 1. Try File System Access API (Chrome/Edge/Opera)
if (window.showSaveFilePicker) {
try {
// Use the pre-acquired file handle for streaming (Chrome/Edge/Opera)
if (fileHandle) {
const writable = await fileHandle.createWritable();
await new Promise((resolve, reject) => {
zip.generateInternalStream({
type: 'uint8array',
compression: 'STORE',
streamFiles: true
})
.on('data', (chunk, metadata) => {
writable.write(chunk);
})
.on('error', (err) => {
writable.close();
reject(err);
})
.on('end', () => {
writable.close();
resolve();
})
.resume();
});
} else {
// Fallback for Firefox/Safari or if user cancelled/API not available
const zipBlob = await zip.generateAsync({
type: 'blob',
compression: 'STORE',
streamFiles: true
});
const url = URL.createObjectURL(zipBlob);
const a = document.createElement('a');
a.href = url;
a.download = `${filename}.zip`;
document.body.appendChild(a);
a.click();
document.body.removeChild(a);
URL.revokeObjectURL(url);
}
completeBulkDownload(notification, true);
} catch (error) {
console.error('ZIP generation failed:', error);
completeBulkDownload(notification, false, 'ZIP creation failed');
}
}
async function initializeZipDownload(defaultName, useFilePicker = false) {
const JSZip = await loadJSZip();
const zip = new JSZip();
let fileHandle = null;
if (useFilePicker && window.showSaveFilePicker) {
try {
const handle = await window.showSaveFilePicker({
suggestedName: `${filename}.zip`,
fileHandle = await window.showSaveFilePicker({
suggestedName: `${defaultName}.zip`,
types: [{
description: 'ZIP Archive',
accept: { 'application/zip': ['.zip'] }
}]
});
writable = await handle.createWritable();
} catch (err) {
if (err.name === 'AbortError') return null; // User cancelled
throw err;
}
}
// 2. Fallback to StreamSaver.js (Firefox/Safari)
else {
const streamSaver = await loadStreamSaver();
writable = streamSaver.createWriteStream(`${filename}.zip`);
// StreamSaver doesn't support aborting via API easily in this flow,
// but closing the writer effectively ends it.
}
// Create zip.js writer
// zip.js requires a specific Writer interface for WritableStream
const zipWriter = new zip.ZipWriter(new zip.WritableStreamWriter(writable));
return { zipWriter, zipModule: zip };
return { zip, fileHandle };
}
async function streamTracksToZip(zipWriter, zipModule, tracks, folderName, api, quality, lyricsManager, notification, startProgressIndex = 0, totalTracks = tracks.length) {
const { BlobReader, TextReader } = zipModule;
async function downloadTracksToZip(zip, tracks, folderName, api, quality, lyricsManager, notification, startProgressIndex = 0, totalTracks = tracks.length) {
for (let i = 0; i < tracks.length; i++) {
const track = tracks[i];
const currentGlobalIndex = startProgressIndex + i;
@ -245,15 +277,9 @@ async function streamTracksToZip(zipWriter, zipModule, tracks, folderName, api,
updateBulkDownloadProgress(notification, currentGlobalIndex, totalTracks, trackTitle);
try {
// Download track (into memory blob)
const blob = await downloadTrackBlob(track, quality, api);
// Write to ZIP stream (and flush to disk immediately)
await zipWriter.add(`${folderName}/${filename}`, new BlobReader(blob));
// Blob is now eligible for GC (as we await the write)
zip.file(`${folderName}/${filename}`, blob);
// Lyrics
if (lyricsManager && lyricsSettings.shouldDownloadLyrics()) {
try {
const lyricsData = await lyricsManager.fetchLyrics(track.id, track);
@ -261,11 +287,11 @@ async function streamTracksToZip(zipWriter, zipModule, tracks, folderName, api,
const lrcContent = lyricsManager.generateLRCContent(lyricsData, track);
if (lrcContent) {
const lrcFilename = filename.replace(/\.[^.]+$/, '.lrc');
await zipWriter.add(`${folderName}/${lrcFilename}`, new TextReader(lrcContent));
zip.file(`${folderName}/${lrcFilename}`, lrcContent);
}
}
} catch (error) {
// Ignore lyrics error
console.log('Could not add lyrics for:', trackTitle);
}
}
} catch (err) {
@ -285,25 +311,21 @@ export async function downloadAlbumAsZip(album, tracks, api, quality, lyricsMana
year: year
});
const streamResult = await createZipStreamWriter(folderName);
if (!streamResult) return; // Cancelled
const { zipWriter, zipModule } = streamResult;
// Only prompt for save location if we have >= 20 tracks (to capture user gesture early)
// Otherwise, we'll auto-download the blob at the end
const initResult = await initializeZipDownload(folderName, tracks.length >= 20);
if (!initResult) return; // User cancelled
const { zip, fileHandle } = initResult;
const coverBlob = await getCoverBlob(api, album.cover || album.album?.cover || album.coverId);
const notification = createBulkDownloadNotification('album', album.title, tracks.length);
try {
const coverBlob = await getCoverBlob(api, album.cover || album.album?.cover || album.coverId);
if (coverBlob) {
await zipWriter.add(`${folderName}/cover.jpg`, new zipModule.BlobReader(coverBlob));
}
await streamTracksToZip(zipWriter, zipModule, tracks, folderName, api, quality, lyricsManager, notification);
await zipWriter.close();
completeBulkDownload(notification, true);
addCoverBlobToZip(zip, folderName, coverBlob);
await downloadTracksToZip(zip, tracks, folderName, api, quality, lyricsManager, notification);
await generateAndDownloadZip(zip, folderName, notification, tracks.length, fileHandle);
} catch (error) {
completeBulkDownload(notification, false, error.message);
try { await zipWriter.close(); } catch (e) {} // Try to close anyway
throw error;
}
}
@ -315,27 +337,22 @@ export async function downloadPlaylistAsZip(playlist, tracks, api, quality, lyri
year: new Date().getFullYear()
});
const streamResult = await createZipStreamWriter(folderName);
if (!streamResult) return; // Cancelled
const { zipWriter, zipModule } = streamResult;
const initResult = await initializeZipDownload(folderName, tracks.length >= 20);
if (!initResult) return; // User cancelled
const { zip, fileHandle } = initResult;
const notification = createBulkDownloadNotification('playlist', playlist.title, tracks.length);
try {
// Cover
// Find a representative cover for the playlist (first track with cover)
const representativeTrack = tracks.find(t => t.album?.cover);
const coverBlob = await getCoverBlob(api, representativeTrack?.album?.cover);
if (coverBlob) {
await zipWriter.add(`${folderName}/cover.jpg`, new zipModule.BlobReader(coverBlob));
}
addCoverBlobToZip(zip, folderName, coverBlob);
await streamTracksToZip(zipWriter, zipModule, tracks, folderName, api, quality, lyricsManager, notification);
await zipWriter.close();
completeBulkDownload(notification, true);
await downloadTracksToZip(zip, tracks, folderName, api, quality, lyricsManager, notification);
await generateAndDownloadZip(zip, folderName, notification, tracks.length, fileHandle);
} catch (error) {
completeBulkDownload(notification, false, error.message);
try { await zipWriter.close(); } catch (e) {}
throw error;
}
}
@ -343,25 +360,23 @@ export async function downloadPlaylistAsZip(playlist, tracks, api, quality, lyri
export async function downloadDiscography(artist, api, quality, lyricsManager = null) {
const rootFolder = `${sanitizeForFilename(artist.name)} discography`;
const streamResult = await createZipStreamWriter(rootFolder);
if (!streamResult) return;
const { zipWriter, zipModule } = streamResult;
// Always use file picker for discography as it's likely large
const initResult = await initializeZipDownload(rootFolder, true);
if (!initResult) return; // User cancelled
const { zip, fileHandle } = initResult;
const allReleases = [...(artist.albums || []), ...(artist.eps || [])];
const notification = createBulkDownloadNotification('discography', artist.name, allReleases.length); // Total is approx tracks, but showing albums for now in text
const notification = createBulkDownloadNotification('discography', artist.name, allReleases.length);
try {
// Calculate total tracks for better progress?
// It's expensive to fetch all album details first. We'll just update text.
let totalTracksDownloaded = 0;
for (let albumIndex = 0; albumIndex < allReleases.length; albumIndex++) {
const album = allReleases[albumIndex];
updateBulkDownloadProgress(notification, albumIndex, allReleases.length, album.title);
try {
const { album: fullAlbum, tracks } = await api.getAlbum(album.id);
const coverBlob = await getCoverBlob(api, fullAlbum.cover || album.cover);
const releaseDateStr = fullAlbum.releaseDate || (tracks[0]?.streamStartDate ? tracks[0].streamStartDate.split('T')[0] : '');
const releaseDate = releaseDateStr ? new Date(releaseDateStr) : null;
@ -374,28 +389,13 @@ export async function downloadDiscography(artist, api, quality, lyricsManager =
});
const fullFolderPath = `${rootFolder}/${albumFolder}`;
// Cover
const coverBlob = await getCoverBlob(api, fullAlbum.cover || album.cover);
if (coverBlob) {
await zipWriter.add(`${fullFolderPath}/cover.jpg`, new zipModule.BlobReader(coverBlob));
}
// We reuse the streamTracksToZip logic but we need to pass just this album's tracks
// and careful with progress bar. streamTracksToZip resets progress?
// Let's call the logic manually to control progress bar or adapt streamTracksToZip.
// Actually, streamTracksToZip updates progress based on its inputs.
// For discography, we might want to keep the "Album X/Y" progress.
// Let's just inline the loop here or simple helper.
const { BlobReader, TextReader } = zipModule;
addCoverBlobToZip(zip, fullFolderPath, coverBlob);
for (const track of tracks) {
const filename = buildTrackFilename(track, quality);
try {
const blob = await downloadTrackBlob(track, quality, api);
await zipWriter.add(`${fullFolderPath}/${filename}`, new BlobReader(blob));
zip.file(`${fullFolderPath}/${filename}`, blob);
if (lyricsManager && lyricsSettings.shouldDownloadLyrics()) {
try {
@ -404,10 +404,12 @@ export async function downloadDiscography(artist, api, quality, lyricsManager =
const lrcContent = lyricsManager.generateLRCContent(lyricsData, track);
if (lrcContent) {
const lrcFilename = filename.replace(/\.[^.]+$/, '.lrc');
await zipWriter.add(`${fullFolderPath}/${lrcFilename}`, new TextReader(lrcContent));
zip.file(`${fullFolderPath}/${lrcFilename}`, lrcContent);
}
}
} catch (e) {}
} catch (error) {
// Silent fail for lyrics in bulk
}
}
} catch (err) {
console.error(`Failed to download track ${track.title}:`, err);
@ -419,11 +421,9 @@ export async function downloadDiscography(artist, api, quality, lyricsManager =
}
}
await zipWriter.close();
completeBulkDownload(notification, true);
await generateAndDownloadZip(zip, rootFolder, notification, allReleases.length, fileHandle);
} catch (error) {
completeBulkDownload(notification, false, error.message);
try { await zipWriter.close(); } catch (e) {}
throw error;
}
}