diff --git a/js/api.js b/js/api.js index 2cecebc..6499e65 100644 --- a/js/api.js +++ b/js/api.js @@ -7,12 +7,13 @@ import { getExtensionFromBlob, getTrackTitle, getFullArtistString, + getTrackDiscNumber, getMimeType, } from './utils.js'; import { trackDateSettings } from './storage.js'; import { APICache } from './cache.js'; import { addMetadataToAudio, prefetchMetadataObjects } from './metadata.js'; -import { DashDownloader } from './dash-downloader.js'; +import { DashDownloader } from './dash-downloader.ts'; import { HlsDownloader } from './hls-downloader.js'; import { MP3EncodingError } from './mp3-encoder.js'; import { loadFfmpeg, FfmpegError } from './ffmpeg.js'; @@ -1288,11 +1289,36 @@ export class LosslessAPI { return streamUrl; } + /** + * Downloads a track or video from TIDAL in the specified quality. + * + * Handles multiple stream types (DASH, HLS, and direct HTTP), applies post-processing + * for audio tracks, adds metadata, and optionally triggers a browser download. + * + * @async + * @param {string} id - The TIDAL track or video ID + * @param {string} [quality='HI_RES_LOSSLESS'] - The desired audio quality (e.g., 'HI_RES_LOSSLESS', 'LOSSLESS', 'HIGH', 'NORMAL'). + * Custom FFMPEG formats are transcoded from LOSSLESS. + * @param {string} filename - The filename to save the downloaded content as + * @param {Object} [options={}] - Additional download options + * @param {Function} [options.onProgress] - Callback function for progress updates with signature: + * `(progressEvent) => void` + * @param {Object} [options.track] - Track metadata object to attach to the audio file + * @param {boolean} [options.calculateDashBytes=true] - Whether to calculate total bytes for DASH streams + * @param {AbortSignal} [options.signal] - AbortSignal to cancel the download + * @param {boolean} [options.triggerDownload=true] - Whether to trigger browser download after completion + * + * @returns {Promise} The downloaded content as a Blob object + * + * @throws {Error} If stream URL cannot be resolved, manifest is missing, or download fails + * @throws {AbortError} If the download is aborted via the signal + * @throws {MP3EncodingError|FfmpegError} If audio transcoding fails + */ async downloadTrack(id, quality = 'HI_RES_LOSSLESS', filename, options = {}) { // Load ffmpeg in the background. loadFfmpeg().catch(console.error); - const { onProgress, track } = options; + const { onProgress, track, calculateDashBytes = true } = options; const prefetchPromises = prefetchMetadataObjects(track, this); const isVideo = track?.type === 'video'; @@ -1345,7 +1371,8 @@ export class LosslessAPI { const downloader = new DashDownloader(); blob = await downloader.downloadDashStream(streamUrl, { signal: options.signal, - onProgress: options.onProgress, + onProgress, + calculateDashBytes: calculateDashBytes ?? true, }); } catch (dashError) { console.error('DASH download failed:', dashError); @@ -1363,7 +1390,7 @@ export class LosslessAPI { const downloader = new HlsDownloader(); blob = await downloader.downloadHlsStream(streamUrl, { signal: options.signal, - onProgress: options.onProgress, + onProgress, }); } catch (hlsError) { console.error('HLS download failed:', hlsError); @@ -1384,7 +1411,7 @@ export class LosslessAPI { let receivedBytes = 0; - if (response.body && onProgress) { + if (response.body) { const reader = response.body.getReader(); const chunks = []; @@ -1396,7 +1423,7 @@ export class LosslessAPI { chunks.push(value); receivedBytes += value.byteLength; - onProgress({ + onProgress?.({ stage: 'downloading', receivedBytes, totalBytes: totalBytes || undefined, @@ -1408,13 +1435,11 @@ export class LosslessAPI { blob = new Blob(chunks, { type: response.headers.get('Content-Type') || defaultMime }); } else { blob = await response.blob(); - if (onProgress) { - onProgress({ - stage: 'downloading', - receivedBytes: blob.size, - totalBytes: blob.size, - }); - } + onProgress?.({ + stage: 'downloading', + receivedBytes: blob.size, + totalBytes: blob.size, + }); } } @@ -1423,12 +1448,10 @@ export class LosslessAPI { // Add metadata if track information is provided if (track) { - if (onProgress) { - onProgress({ - stage: 'processing', - message: 'Adding metadata...', - }); - } + onProgress?.({ + stage: 'processing', + message: 'Adding metadata...', + }); const enrichedTrack = { ...track }; if (lookup.info) { @@ -1445,38 +1468,17 @@ export class LosslessAPI { (track.album?.totalDiscs == null || track.album?.numberOfTracksOnDisc == null) ) { try { - // Broad disc-field resolver — mirrors getExplicitTrackDiscNumber in downloads.js - const resolveDiscNumber = (t) => { - const candidates = [ - t.volumeNumber, - t.discNumber, - t.mediaNumber, - t.media_number, - t.volume, - t.disc, - t.disc_no, - t.discNo, - t.disc_number, - t.mediaMetadata?.discNumber, - ]; - for (const c of candidates) { - const parsed = parseInt(c, 10); - if (Number.isFinite(parsed) && parsed > 0) return parsed; - } - return 1; - }; - const albumData = await this.getAlbum(track.album.id); if (albumData.tracks?.length > 0) { const discTrackCounts = new Map(); let maxDiscNumber = 0; for (const t of albumData.tracks) { - const dn = resolveDiscNumber(t); + const dn = getTrackDiscNumber(t); discTrackCounts.set(dn, (discTrackCounts.get(dn) || 0) + 1); if (dn > maxDiscNumber) maxDiscNumber = dn; } const totalDiscs = maxDiscNumber || 1; - const discNumber = resolveDiscNumber(track); + const discNumber = getTrackDiscNumber(track); enrichedTrack.album = { ...(enrichedTrack.album || {}), totalDiscs: track.album?.totalDiscs ?? totalDiscs, @@ -1493,17 +1495,20 @@ export class LosslessAPI { } } - // Detect actual format and fix filename extension if needed - const detectedExtension = await getExtensionFromBlob(blob); - let finalFilename = filename; + if (options.triggerDownload ?? true) { + // Detect actual format and fix filename extension if needed + const detectedExtension = await getExtensionFromBlob(blob); + let finalFilename = filename; - // Replace extension if it doesn't match detected format - const currentExtension = filename.split('.').pop()?.toLowerCase(); - if (currentExtension && currentExtension !== detectedExtension) { - finalFilename = filename.replace(/\.[^.]+$/, `.${detectedExtension}`); + // Replace extension if it doesn't match detected format + const currentExtension = filename.split('.').pop()?.toLowerCase(); + if (currentExtension && currentExtension !== detectedExtension) { + finalFilename = filename.replace(/\.[^.]+$/, `.${detectedExtension}`); + } + + triggerDownload(blob, finalFilename); } - triggerDownload(blob, finalFilename); return blob; } catch (error) { if (error.name === 'AbortError') { diff --git a/js/dash-downloader.js b/js/dash-downloader.ts similarity index 61% rename from js/dash-downloader.js rename to js/dash-downloader.ts index a67fa8b..3379488 100644 --- a/js/dash-downloader.js +++ b/js/dash-downloader.ts @@ -1,8 +1,67 @@ +import { AbortError } from './errorTypes'; +import { DownloadProgress } from './progressEvents'; + +export class DashDownloadProgress extends DownloadProgress { + public readonly stage = 'downloading'; + + constructor( + public readonly receivedBytes: number, + public readonly totalBytes: number | undefined, + public readonly currentSegment: number, + public readonly totalSegments: number + ) { + super(receivedBytes, totalBytes); + } +} + +export interface DashDownloadOptions { + onProgress?: MonochromeProgressListener; + signal?: AbortSignal; + calculateDashBytes?: boolean; +} + +interface DashSegment { + number: number; + time: number; +} + +interface DashManifest { + baseUrl: string; + initialization: string | null; + media: string | null; + segments: DashSegment[]; + repId: string | null; + mimeType: string | null; +} + export class DashDownloader { constructor() {} - async downloadDashStream(manifestBlobUrl, options = {}) { - const { onProgress, signal } = options; + async getTotalSize(urls: string[], signal?: AbortSignal): Promise { + try { + let totalSize = 0; + + await Promise.all( + urls.map(async (url) => { + const result = await fetch(url, { method: 'HEAD', signal }); + + if (result.ok) { + const contentLength = result.headers.get('Content-Length'); + if (contentLength) totalSize += parseInt(contentLength, 10); + } else { + throw new Error(`Failed to fetch segment HEAD: ${result.status}`); + } + }) + ); + + return totalSize; + } catch { + return undefined; + } + } + + async downloadDashStream(manifestBlobUrl: string, options: DashDownloadOptions = {}): Promise { + const { onProgress, signal, calculateDashBytes = true } = options; // 1. Fetch and Parse Manifest const response = await fetch(manifestBlobUrl); @@ -18,24 +77,30 @@ export class DashDownloader { const mimeType = manifest.mimeType || 'audio/mp4'; // 3. Download Segments - const chunks = []; + const chunks: ArrayBuffer[] = []; let downloadedBytes = 0; - // Estimate total size? Hard to know exactly without Content-Length of each. - // We can just track progress by segment count. + const totalSegments = urls.length; + const totalSize = calculateDashBytes ? await this.getTotalSize(urls, signal) : undefined; for (let i = 0; i < urls.length; i++) { - if (signal?.aborted) throw new Error('AbortError'); + if (signal?.aborted) throw new AbortError(); + + onProgress?.(new DashDownloadProgress(downloadedBytes, totalSize ?? undefined, i, totalSegments)); const url = urls[i]; const segmentResponse = await fetch(url, { signal }); if (!segmentResponse.ok) { - // Retry once? console.warn(`Failed to fetch segment ${i}, retrying...`); await new Promise((r) => setTimeout(r, 1000)); + const retryResponse = await fetch(url, { signal }); - if (!retryResponse.ok) throw new Error(`Failed to fetch segment ${i}: ${retryResponse.status}`); + + if (!retryResponse.ok) { + throw new Error(`Failed to fetch segment ${i}: ${retryResponse.status}`); + } + const chunk = await retryResponse.arrayBuffer(); chunks.push(chunk); downloadedBytes += chunk.byteLength; @@ -45,22 +110,20 @@ export class DashDownloader { downloadedBytes += chunk.byteLength; } - if (onProgress) { - onProgress({ - stage: 'downloading', - receivedBytes: downloadedBytes, // accurate byte count - totalBytes: undefined, // Unknown total - currentSegment: i + 1, - totalSegments: totalSegments, - }); - } + onProgress?.({ + stage: 'downloading', + receivedBytes: downloadedBytes, + totalBytes: totalSize ?? undefined, + currentSegment: i + 1, + totalSegments, + }); } // 4. Concatenate return new Blob(chunks, { type: mimeType }); } - parseManifest(manifestText) { + parseManifest(manifestText: string): DashManifest { const parser = new DOMParser(); const xml = parser.parseFromString(manifestText, 'text/xml'); @@ -70,25 +133,22 @@ export class DashDownloader { const period = mpd.querySelector('Period'); if (!period) throw new Error('Invalid DASH manifest: No Period tag'); - // Prefer highest bandwidth audio adaptation set const adaptationSets = Array.from(period.querySelectorAll('AdaptationSet')); adaptationSets.sort((a, b) => { - const getMaxBandwidth = (set) => { + const getMaxBandwidth = (set: Element) => { const reps = Array.from(set.querySelectorAll('Representation')); return reps.length ? Math.max(...reps.map((r) => parseInt(r.getAttribute('bandwidth') || '0', 10))) : 0; }; + return getMaxBandwidth(b) - getMaxBandwidth(a); }); - let audioSet = adaptationSets.find((as) => as.getAttribute('mimeType')?.startsWith('audio')); + let audioSet = adaptationSets.find((as) => as.getAttribute('mimeType')?.startsWith('audio')) ?? null; - // Fallback: look for any adaptation set if mimeType is missing (rare) if (!audioSet && adaptationSets.length > 0) audioSet = adaptationSets[0]; if (!audioSet) throw new Error('No AdaptationSet found'); - // Find Representation - // Get all representations and sort by bandwidth descending const representations = Array.from(audioSet.querySelectorAll('Representation')).sort((a, b) => { const bwA = parseInt(a.getAttribute('bandwidth') || '0'); const bwB = parseInt(b.getAttribute('bandwidth') || '0'); @@ -96,55 +156,47 @@ export class DashDownloader { }); if (representations.length === 0) throw new Error('No Representation found'); + const rep = representations[0]; const repId = rep.getAttribute('id'); - // Find SegmentTemplate - // Can be in Representation or AdaptationSet const segmentTemplate = rep.querySelector('SegmentTemplate') || audioSet.querySelector('SegmentTemplate'); + if (!segmentTemplate) throw new Error('No SegmentTemplate found'); const initialization = segmentTemplate.getAttribute('initialization'); const media = segmentTemplate.getAttribute('media'); const startNumber = parseInt(segmentTemplate.getAttribute('startNumber') || '1', 10); - // BaseURL - // Can be at MPD, Period, AdaptationSet, or Representation level. - // We strictly need to find the "deepest" one or combine them? - // Usually simpler manifests have it at one level. - // Let's resolve closest BaseURL. const baseUrlTag = rep.querySelector('BaseURL') || audioSet.querySelector('BaseURL') || period.querySelector('BaseURL') || mpd.querySelector('BaseURL'); - const baseUrl = baseUrlTag ? baseUrlTag.textContent.trim() : ''; - // SegmentTimeline + const baseUrl = baseUrlTag?.textContent?.trim() || ''; + const segmentTimeline = segmentTemplate.querySelector('SegmentTimeline'); - const segments = []; + const segments: DashSegment[] = []; if (segmentTimeline) { const sElements = segmentTimeline.querySelectorAll('S'); + let currentTime = 0; let currentNumber = startNumber; sElements.forEach((s) => { - // t is optional, defaults to previous end const tAttr = s.getAttribute('t'); if (tAttr) currentTime = parseInt(tAttr, 10); - const d = parseInt(s.getAttribute('d'), 10); + const d = parseInt(s.getAttribute('d') || '0', 10); const r = parseInt(s.getAttribute('r') || '0', 10); - // Initial segment segments.push({ number: currentNumber, time: currentTime }); + currentTime += d; currentNumber++; - // Repeats - // r is the number of REPEATS (so total occurrences = 1 + r) - // If r is negative, it refers to open-ended? (Usually not in static manifests) for (let i = 0; i < r; i++) { segments.push({ number: currentNumber, time: currentTime }); currentTime += d; @@ -163,43 +215,40 @@ export class DashDownloader { }; } - generateSegmentUrls(manifest) { + generateSegmentUrls(manifest: DashManifest): string[] { const { baseUrl, initialization, media, segments, repId } = manifest; - const urls = []; - // Helper to resolve template strings - const resolveTemplate = (template, number, time) => { + const urls: string[] = []; + + const resolveTemplate = (template: string, number: number, time: number): string => { return template - .replace(/\$RepresentationID\$/g, repId) - .replace(/\$Number(?:%0([0-9]+)d)?\$/g, (match, width) => { + .replace(/\$RepresentationID\$/g, repId ?? '') + .replace(/\$Number(?:%0([0-9]+)d)?\$/g, (_, width) => { if (width) { return number.toString().padStart(parseInt(width), '0'); } - return number; + return number.toString(); }) - .replace(/\$Time(?:%0([0-9]+)d)?\$/g, (match, width) => { + .replace(/\$Time(?:%0([0-9]+)d)?\$/g, (_, width) => { if (width) { return time.toString().padStart(parseInt(width), '0'); } - return time; + return time.toString(); }); }; - // Helper to join paths handling slashes - const joinPath = (base, part) => { + const joinPath = (base: string, part: string): string => { if (!base) return part; - if (part.startsWith('http')) return part; // Absolute path + if (part.startsWith('http')) return part; return base.endsWith('/') ? base + part : base + '/' + part; }; - // 1. Initialization Segment if (initialization) { - const initPath = resolveTemplate(initialization, 0, 0); // Init often doesn't use Number/Time but just in case + const initPath = resolveTemplate(initialization, 0, 0); urls.push(joinPath(baseUrl, initPath)); } - // 2. Media Segments - if (segments && segments.length > 0) { + if (media && segments.length > 0) { segments.forEach((seg) => { const path = resolveTemplate(media, seg.number, seg.time); urls.push(joinPath(baseUrl, path)); diff --git a/js/downloads.js b/js/downloads.js index 5b178de..088403a 100644 --- a/js/downloads.js +++ b/js/downloads.js @@ -11,16 +11,11 @@ import { getExtensionFromBlob, escapeHtml, getTrackDiscNumber, - getFullArtistString, - getMimeType, } from './utils.js'; +import { AbortError } from './errorTypes.ts'; import { lyricsSettings, bulkDownloadSettings, playlistSettings } from './storage.js'; -import { addMetadataToAudio, prefetchMetadataObjects } from './metadata.js'; -import { DashDownloader } from './dash-downloader.js'; import { generateM3U, generateM3U8, generateCUE, generateNFO, generateJSON } from './playlist-generator.js'; -import { loadFfmpeg } from './ffmpeg.js'; -import { triggerDownload, applyAudioPostProcessing } from './download-utils.ts'; -import { isCustomFormat } from './ffmpegFormats.ts'; +import { triggerDownload } from './download-utils.ts'; import { ZipStreamWriter, ZipBlobWriter, ZipNeutralinoWriter, FolderPickerWriter } from './bulk-download-writer.ts'; const downloadTasks = new Map(); @@ -296,168 +291,18 @@ function removeBulkDownloadTask(notifEl) { }, 300); } -async function downloadTrackBlob( - track, - quality, - api, - lyricsManager = null, - signal = null, - onProgress = null, - coverBlob = null -) { - // Load ffmpeg in the background. - loadFfmpeg().catch(console.error); - - const prefetchPromises = prefetchMetadataObjects(track, api, coverBlob); - - let enrichedTrack = { - ...track, - artist: track.artist || (track.artists && track.artists.length > 0 ? track.artists[0] : null), - }; - - // Custom FFMPEG formats are not native TIDAL qualities; download LOSSLESS and transcode - const downloadQuality = isCustomFormat(quality) ? 'LOSSLESS' : quality; - - try { - const fullTrack = await api.getTrackMetadata(track.id); - if (fullTrack) { - enrichedTrack = { - ...fullTrack, - ...enrichedTrack, - artist: enrichedTrack.artist || fullTrack.artist, - album: { - ...(fullTrack.album || {}), - ...(enrichedTrack.album || {}), - }, - // Preserve explicit disc fields from either source - discNumber: enrichedTrack.discNumber ?? fullTrack.discNumber, - volumeNumber: enrichedTrack.volumeNumber ?? fullTrack.volumeNumber, - }; - } - } catch { - // Non-fatal: continue with best available track payload - } - - if (enrichedTrack.album?.id) { - try { - const albumData = await api.getAlbum(enrichedTrack.album.id); - if (albumData.album && (!enrichedTrack.album.title || !enrichedTrack.album.artist)) { - enrichedTrack.album = { - ...enrichedTrack.album, - ...albumData.album, - }; - } - if (albumData.tracks?.length > 0) { - const { totalDiscs, tracksPerDisc } = await computeDiscInfo(albumData.tracks, api); - const discNumber = getTrackDiscNumber(enrichedTrack) || 1; - enrichedTrack.album = { - ...enrichedTrack.album, - totalDiscs, - numberOfTracksOnDisc: tracksPerDisc.get(discNumber), - }; - } - } catch (error) { - console.warn('Failed to fetch album data for metadata:', error); - } - } - - const lookup = await api.getTrack(track.id, downloadQuality); - let streamUrl; - - if (lookup.originalTrackUrl) { - streamUrl = lookup.originalTrackUrl; - } else { - streamUrl = api.extractStreamUrlFromManifest(lookup.info.manifest); - if (!streamUrl) { - throw new Error('Could not resolve stream URL'); - } - } - - if (lookup.info) { - enrichedTrack.replayGain = { - trackReplayGain: lookup.info.trackReplayGain, - trackPeakAmplitude: lookup.info.trackPeakAmplitude, - albumReplayGain: lookup.info.albumReplayGain, - albumPeakAmplitude: lookup.info.albumPeakAmplitude, - }; - } - - // Handle DASH streams (blob URLs) - let blob; - if (streamUrl.startsWith('blob:')) { - try { - const downloader = new DashDownloader(); - blob = await downloader.downloadDashStream(streamUrl, { signal }); - } catch (dashError) { - console.error('DASH download failed:', dashError); - // Fallback - if (downloadQuality !== 'LOSSLESS') { - console.warn('Falling back to LOSSLESS (16-bit) download.'); - return downloadTrackBlob(track, 'LOSSLESS', api, lyricsManager, signal, onProgress, coverBlob); - } - throw dashError; - } - } else { - const response = await fetch(streamUrl, { signal }); - if (!response.ok) { - throw new Error(`Failed to fetch track: ${response.status}`); - } - blob = await response.blob(); - } - - const coverBlobToEmbed = await prefetchPromises.coverFetch; - const extraFiles = []; - const ffmpegMetadataArgs = []; - - if (coverBlobToEmbed) { - const coverBuffer = await coverBlobToEmbed.arrayBuffer(); - const coverExt = getMimeType(new Uint8Array(coverBuffer)) === 'image/png' ? 'png' : 'jpg'; - const coverName = `cover.${coverExt}`; - extraFiles.push({ - name: coverName, - data: coverBuffer, - }); - ffmpegMetadataArgs.push('-i', coverName); - } - - if (enrichedTrack) { - ffmpegMetadataArgs.push( - '-metadata', - `title=${getTrackTitle(enrichedTrack)}`, - '-metadata', - `artist=${getFullArtistString(enrichedTrack)}`, - '-metadata', - `album=${enrichedTrack.album?.title || ''}`, - '-metadata', - `album_artist=${enrichedTrack.album?.artist?.name || enrichedTrack.artist?.name || ''}` - ); - - const trackNum = enrichedTrack.trackNumber; - if (trackNum) { - const totalTracks = enrichedTrack.album?.numberOfTracks; - ffmpegMetadataArgs.push('-metadata', `track=${trackNum}${totalTracks ? `/${totalTracks}` : ''}`); - } - - const discNum = enrichedTrack.volumeNumber || enrichedTrack.discNumber; - if (discNum) { - ffmpegMetadataArgs.push('-metadata', `disc=${discNum}`); - } - - const releaseDate = enrichedTrack.album?.releaseDate || enrichedTrack?.streamStartDate; - if (releaseDate) { - ffmpegMetadataArgs.push('-metadata', `date=${releaseDate.split('-')[0]}`); - } - } - - // Apply audio post-processing (custom format transcoding + lossless container conversion) - blob = await applyAudioPostProcessing(blob, quality, onProgress, signal); +async function downloadTrackBlob(track, quality, api, signal = null, onProgress = null) { + const blob = await api.downloadTrack(track.id, quality, undefined, { + track, + signal, + onProgress, + triggerDownload: false, + calculateDashBytes: false, + }); // Detect actual format from blob signature BEFORE adding metadata const extension = await getExtensionFromBlob(blob); - // Add metadata to the blob - blob = await addMetadataToAudio(blob, enrichedTrack, api, quality, prefetchPromises); - return { blob, extension }; } @@ -473,7 +318,7 @@ async function bulkDownloadSequentially(tracks, api, quality, lyricsManager, not updateBulkDownloadProgress(notification, i, tracks.length, trackTitle); try { - const { blob, extension } = await downloadTrackBlob(track, quality, api, null, signal, null, coverBlob); + const { blob, extension } = await downloadTrackBlob(track, quality, api, signal, null); const filename = buildTrackFilename(track, quality, extension); triggerDownload(blob, filename); @@ -499,7 +344,7 @@ async function bulkDownloadSequentially(tracks, api, quality, lyricsManager, not } } -async function bulkDownloadToZip( +async function bulkDownload( tracks, folderName, api, @@ -530,21 +375,22 @@ async function bulkDownloadToZip( if (signal.aborted) break; const track = tracks[i]; const trackTitle = getTrackTitle(track); + let fileFraction = 0; updateBulkDownloadProgress(notification, i, tracks.length, trackTitle); try { - const { blob, extension } = await downloadTrackBlob( - track, - quality, - api, - null, - signal, - (p) => { - updateBulkDownloadProgress(notification, i, tracks.length, trackTitle, p); - }, - coverBlob - ); + const { blob, extension } = await downloadTrackBlob(track, quality, api, signal, (p) => { + if (p && p.stage === 'downloading') { + if (p.totalBytes && p.receivedBytes) { + fileFraction = p.receivedBytes / p.totalBytes; + } else if (p.currentSegment && p.totalSegments) { + fileFraction = p.currentSegment / p.totalSegments; + } + } + fileFraction = Math.min(fileFraction, 0.99); // Cap at 99% to avoid showing 100% before finalization + updateBulkDownloadProgress(notification, i + fileFraction, tracks.length, trackTitle, p); + }); const filename = buildTrackFilename(track, quality, extension); const discNumber = discLayout.resolveDiscNumber(i); const discPath = separateByDisc ? `${getDiscFolderName(discNumber)}/${filename}` : filename; @@ -717,7 +563,7 @@ async function startBulkDownload( const writer = await createBulkWriter(defaultName); if (writer) { - await bulkDownloadToZip( + await bulkDownload( tracks, defaultName, api, @@ -846,15 +692,7 @@ export async function downloadDiscography(artist, selectedReleases, api, quality const track = tracks[i]; if (signal.aborted) break; try { - const { blob, extension } = await downloadTrackBlob( - track, - quality, - api, - null, - signal, - null, - coverBlob - ); + const { blob, extension } = await downloadTrackBlob(track, quality, api, signal, null); const filename = buildTrackFilename(track, quality, extension); const discNumber = discLayout.resolveDiscNumber(i); const discPath = separateByDisc ? `${getDiscFolderName(discNumber)}/${filename}` : filename; @@ -1034,14 +872,14 @@ function updateBulkDownloadProgress(notifEl, current, total, currentItem, ffmpeg const percent = ffmpegProgress.progress ? Math.round(ffmpegProgress.progress) : 100; progressFill.style.width = `${percent}%`; progressFill.style.background = '#3b82f6'; // Blue for encoding - statusEl.textContent = `Converting ${current}/${total}: ${percent}%`; + statusEl.textContent = `Converting ${Math.ceil(current)}/${total}: ${percent}%`; return; } const percent = total > 0 ? Math.round((current / total) * 100) : 0; progressFill.style.width = `${percent}%`; progressFill.style.background = 'var(--highlight)'; - statusEl.textContent = `${current}/${total} - ${currentItem}`; + statusEl.textContent = `${Math.floor(current)}/${total} - ${currentItem}`; } function completeBulkDownload(notifEl, success = true, message = null) { @@ -1143,6 +981,7 @@ export async function downloadTrackWithMetadata(track, quality, api, lyricsManag onProgress: (progress) => { updateDownloadProgress(track.id, progress); }, + calculateDashBytes: true, }); completeDownloadTask(track.id, true); diff --git a/js/errorTypes.ts b/js/errorTypes.ts new file mode 100644 index 0000000..8ae9cdb --- /dev/null +++ b/js/errorTypes.ts @@ -0,0 +1,6 @@ +export class AbortError extends Error { + constructor(cause: string = 'The task was aborted.') { + super(cause); + this.name = 'AbortError'; + } +} diff --git a/js/progressEvents.ts b/js/progressEvents.ts new file mode 100644 index 0000000..6a7ec69 --- /dev/null +++ b/js/progressEvents.ts @@ -0,0 +1,20 @@ +declare global { + type MonochromeProgress = { + stage: string; + } & T; + + type MonochromeProgressMessage = { + message: string; + }; + + type MonochromeProgressListener = (progress: T) => void; +} + +export class DownloadProgress implements MonochromeProgress { + public readonly stage = 'downloading'; + + constructor( + public readonly receivedBytes: number, + public readonly totalBytes: number | undefined + ) {} +}