255 lines
8.8 KiB
JavaScript
255 lines
8.8 KiB
JavaScript
// js/qobuz-api.js
|
|
// Qobuz API integration for Monochrome Music
|
|
|
|
const QOBUZ_API_BASE = 'https://qobuz.squid.wtf/api';
|
|
|
|
export class QobuzAPI {
|
|
constructor() {
|
|
this.baseUrl = QOBUZ_API_BASE;
|
|
}
|
|
|
|
async fetchWithRetry(endpoint, options = {}) {
|
|
const url = `${this.baseUrl}${endpoint}`;
|
|
|
|
try {
|
|
const response = await fetch(url, { signal: options.signal });
|
|
|
|
if (!response.ok) {
|
|
throw new Error(`Request failed with status ${response.status}`);
|
|
}
|
|
|
|
const data = await response.json();
|
|
return data;
|
|
} catch (error) {
|
|
if (error.name === 'AbortError') throw error;
|
|
console.error('Qobuz API request failed:', error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
// Search tracks
|
|
async searchTracks(query, options = {}) {
|
|
try {
|
|
const data = await this.fetchWithRetry(`/get-music?q=${encodeURIComponent(query)}`);
|
|
|
|
if (!data.success || !data.data) {
|
|
return { items: [], limit: 0, offset: 0, totalNumberOfItems: 0 };
|
|
}
|
|
|
|
// Transform Qobuz tracks to match Tidal format
|
|
const tracks = (data.data.tracks?.items || []).map((track) => this.transformTrack(track));
|
|
|
|
return {
|
|
items: tracks,
|
|
limit: data.data.tracks?.limit || tracks.length,
|
|
offset: data.data.tracks?.offset || 0,
|
|
totalNumberOfItems: data.data.tracks?.total || tracks.length,
|
|
};
|
|
} catch (error) {
|
|
if (error.name === 'AbortError') throw error;
|
|
console.error('Qobuz track search failed:', error);
|
|
return { items: [], limit: 0, offset: 0, totalNumberOfItems: 0 };
|
|
}
|
|
}
|
|
|
|
// Search albums
|
|
async searchAlbums(query, options = {}) {
|
|
try {
|
|
const data = await this.fetchWithRetry(`/get-music?q=${encodeURIComponent(query)}`);
|
|
|
|
if (!data.success || !data.data) {
|
|
return { items: [], limit: 0, offset: 0, totalNumberOfItems: 0 };
|
|
}
|
|
|
|
// Transform Qobuz albums to match Tidal format
|
|
const albums = (data.data.albums?.items || []).map((album) => this.transformAlbum(album));
|
|
|
|
return {
|
|
items: albums,
|
|
limit: data.data.albums?.limit || albums.length,
|
|
offset: data.data.albums?.offset || 0,
|
|
totalNumberOfItems: data.data.albums?.total || albums.length,
|
|
};
|
|
} catch (error) {
|
|
if (error.name === 'AbortError') throw error;
|
|
console.error('Qobuz album search failed:', error);
|
|
return { items: [], limit: 0, offset: 0, totalNumberOfItems: 0 };
|
|
}
|
|
}
|
|
|
|
// Search artists
|
|
async searchArtists(query, options = {}) {
|
|
try {
|
|
const data = await this.fetchWithRetry(`/get-music?q=${encodeURIComponent(query)}`);
|
|
|
|
if (!data.success || !data.data) {
|
|
return { items: [], limit: 0, offset: 0, totalNumberOfItems: 0 };
|
|
}
|
|
|
|
// Transform Qobuz artists to match Tidal format
|
|
const artists = (data.data.artists?.items || []).map((artist) => this.transformArtist(artist));
|
|
|
|
return {
|
|
items: artists,
|
|
limit: data.data.artists?.limit || artists.length,
|
|
offset: data.data.artists?.offset || 0,
|
|
totalNumberOfItems: data.data.artists?.total || artists.length,
|
|
};
|
|
} catch (error) {
|
|
if (error.name === 'AbortError') throw error;
|
|
console.error('Qobuz artist search failed:', error);
|
|
return { items: [], limit: 0, offset: 0, totalNumberOfItems: 0 };
|
|
}
|
|
}
|
|
|
|
// Get track details
|
|
async getTrack(id) {
|
|
try {
|
|
// For Qobuz, we'll need to search or get from album
|
|
// Since the API might not have a direct track endpoint
|
|
const data = await this.fetchWithRetry(`/get-music?q=${encodeURIComponent(id)}`);
|
|
|
|
if (!data.success || !data.data) {
|
|
throw new Error('Track not found');
|
|
}
|
|
|
|
const track = data.data.tracks?.items?.find((t) => t.id === id || t.isrc === id);
|
|
if (!track) {
|
|
throw new Error('Track not found');
|
|
}
|
|
|
|
return this.transformTrack(track);
|
|
} catch (error) {
|
|
console.error('Qobuz getTrack failed:', error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
// Get album details
|
|
async getAlbum(id) {
|
|
try {
|
|
const data = await this.fetchWithRetry(`/get-album?album_id=${encodeURIComponent(id)}`);
|
|
|
|
if (!data.success || !data.data) {
|
|
throw new Error('Album not found');
|
|
}
|
|
|
|
const album = this.transformAlbum(data.data);
|
|
const tracks = (data.data.tracks || []).map((track) => this.transformTrack(track, data.data));
|
|
|
|
return { album, tracks };
|
|
} catch (error) {
|
|
console.error('Qobuz getAlbum failed:', error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
// Get artist details
|
|
async getArtist(id) {
|
|
try {
|
|
const data = await this.fetchWithRetry(`/get-artist?artist_id=${encodeURIComponent(id)}`);
|
|
|
|
if (!data.success || !data.data) {
|
|
throw new Error('Artist not found');
|
|
}
|
|
|
|
const artist = this.transformArtist(data.data);
|
|
const albums = (data.data.albums || []).map((album) => this.transformAlbum(album));
|
|
|
|
return { ...artist, albums, eps: [], tracks: [] };
|
|
} catch (error) {
|
|
console.error('Qobuz getArtist failed:', error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
// Transform Qobuz track to Tidal-like format
|
|
transformTrack(track, albumData = null) {
|
|
return {
|
|
id: `q:${track.id}`,
|
|
title: track.title,
|
|
duration: track.duration,
|
|
artist: track.artist ? this.transformArtist(track.artist) : null,
|
|
artists: track.artists ? track.artists.map((a) => this.transformArtist(a)) : [],
|
|
album: albumData ? this.transformAlbum(albumData) : track.album ? this.transformAlbum(track.album) : null,
|
|
audioQuality: this.mapQuality(track.streaming_quality),
|
|
explicit: track.parental_warning || false,
|
|
trackNumber: track.track_number,
|
|
volumeNumber: track.media_number || 1,
|
|
isrc: track.isrc,
|
|
provider: 'qobuz',
|
|
originalId: track.id,
|
|
};
|
|
}
|
|
|
|
// Transform Qobuz album to Tidal-like format
|
|
transformAlbum(album) {
|
|
return {
|
|
id: `q:${album.id}`,
|
|
title: album.title,
|
|
artist: album.artist ? this.transformArtist(album.artist) : null,
|
|
artists: album.artists ? album.artists.map((a) => this.transformArtist(a)) : [],
|
|
numberOfTracks: album.tracks_count || 0,
|
|
releaseDate: album.release_date_original || album.release_date,
|
|
cover: album.image?.large || album.image?.medium || album.image?.small,
|
|
explicit: album.parental_warning || false,
|
|
type: album.album_type === 'ep' ? 'EP' : album.album_type === 'single' ? 'SINGLE' : 'ALBUM',
|
|
provider: 'qobuz',
|
|
originalId: album.id,
|
|
};
|
|
}
|
|
|
|
// Transform Qobuz artist to Tidal-like format
|
|
transformArtist(artist) {
|
|
return {
|
|
id: `q:${artist.id}`,
|
|
name: artist.name,
|
|
picture: artist.image?.large || artist.image?.medium || artist.image?.small,
|
|
provider: 'qobuz',
|
|
originalId: artist.id,
|
|
};
|
|
}
|
|
|
|
// Map Qobuz quality to Tidal quality format
|
|
mapQuality(qobuzQuality) {
|
|
const qualityMap = {
|
|
MP3: 'HIGH',
|
|
FLAC: 'LOSSLESS',
|
|
HiRes: 'HI_RES_LOSSLESS',
|
|
};
|
|
return qualityMap[qobuzQuality] || 'LOSSLESS';
|
|
}
|
|
|
|
// Get cover URL
|
|
getCoverUrl(coverId, size = '320') {
|
|
if (!coverId) {
|
|
return `https://picsum.photos/seed/${Math.random()}/${size}`;
|
|
}
|
|
|
|
// Qobuz cover URLs are usually full URLs
|
|
if (typeof coverId === 'string' && coverId.startsWith('http')) {
|
|
return coverId;
|
|
}
|
|
|
|
return coverId;
|
|
}
|
|
|
|
// Get stream URL for a track
|
|
async getStreamUrl(trackId) {
|
|
try {
|
|
const cleanId = trackId.replace(/^q:/, '');
|
|
const data = await this.fetchWithRetry(`/download-music?track_id=${encodeURIComponent(cleanId)}`);
|
|
|
|
if (!data.success || !data.data?.url) {
|
|
throw new Error('Stream URL not available');
|
|
}
|
|
|
|
return data.data.url;
|
|
} catch (error) {
|
|
console.error('Qobuz getStreamUrl failed:', error);
|
|
throw error;
|
|
}
|
|
}
|
|
}
|
|
|
|
export const qobuzAPI = new QobuzAPI();
|