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

feat(downloads): dash progress / remove nearly duplicate downloadTrackBlob logic from downloads.js

Browse source
This commit is contained in:
Daniel 2026-03-12 19:13:24 +00:00 committed by GitHub
parent 4445cdcd2e
commit 574e42ba1e
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
5 changed files with 215 additions and 296 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

105
js/api.js
View file

@ -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<Blob>} 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') {

161
js/dash-downloader.js → js/dash-downloader.ts
View file

@ -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<DashDownloadProgress>;
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<number | undefined> {
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<Blob> {
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));

219
js/downloads.js
View file

@ -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);

6
js/errorTypes.ts Normal file
View file

@ -0,0 +1,6 @@
export class AbortError extends Error {
constructor(cause: string = 'The task was aborted.') {
super(cause);
this.name = 'AbortError';
}
}

20
js/progressEvents.ts Normal file
View file

@ -0,0 +1,20 @@
declare global {
type MonochromeProgress<T = {}> = {
stage: string;
} & T;
type MonochromeProgressMessage<T = MonochromeProgress> = {
message: string;
};
type MonochromeProgressListener<T = MonochromeProgress> = (progress: T) => void;
}
export class DownloadProgress implements MonochromeProgress {
public readonly stage = 'downloading';
constructor(
public readonly receivedBytes: number,
public readonly totalBytes: number | undefined
) {}
}