Add missing streamUrlHQ; exclude undefined vals

src/lib/article/ArticleParser.ts

@@ -6,6 +6,7 @@ import { ParseError, brToNewLine, isAbsoluteUrl, normalizeUrl, stripTags } from
 import { ImageFormat } from '../types/Image';
 import Album from '../types/Album';
 import { EOL } from 'os';
+import Track from '../types/Track';
 
 interface ArticleParseOptions {
   imageBaseUrl: string;
@@ -115,14 +116,22 @@ export default class ArticleParser {
           if (player.band_image_id && mediaItem.artist && opts.artistImageFormat?.id) {
             mediaItem.artist.imageUrl = `${opts.imageBaseUrl}/img/${player.band_image_id}_${opts.artistImageFormat.id}.jpg`;
           }
-          if (mediaItemType === 'album' && Array.isArray(player.tracklist)) {
-            (mediaItem as Album).tracks = player.tracklist.map((trackInfo: any) => ({
-              position: trackInfo.track_number,
-              name: trackInfo.track_title,
-              duration: trackInfo.audio_track_duration,
-              streamUrl: trackInfo.audio_url?.['mp3-128'],
-              streamUrlHQ: trackInfo.audio_url?.['mp3-v0']
-            }));
+          const tracklist = player.tracklist;
+          if (mediaItemType === 'album' && Array.isArray(tracklist)) {
+            (mediaItem as Album).tracks = tracklist.reduce<Omit<Track, 'type'>[]>((result, trackInfo: any) => {
+              const track: Omit<Track, 'type'> = {
+                position: trackInfo.track_number,
+                name: trackInfo.track_title,
+                duration: trackInfo.audio_track_duration,
+                streamUrl: trackInfo.audio_url?.['mp3-128']
+              };
+              const streamUrlHQ = trackInfo.audio_url?.['mp3-v0'];
+              if (streamUrlHQ) {
+                track.streamUrlHQ = streamUrlHQ;
+              }
+              result.push(track);
+              return result;
+            }, []);
           }
 
           article.mediaItems.push(mediaItem);

src/lib/discovery/DiscoverResultParser.ts

@@ -40,9 +40,12 @@ export default class DiscoverResultParser {
           album.featuredTrack = {
             name: item.featured_track.title,
             duration: item.featured_track.duration,
-            streamUrl: item.featured_track.file?.['mp3-128'],
-            streamUrlHQ: item.featured_track.file?.['mp3-v0']
+            streamUrl: item.featured_track.file?.['mp3-128']
           };
+          const streamUrlHQ = item.featured_track.file?.['mp3-v0'];
+          if (streamUrlHQ) {
+            album.featuredTrack.streamUrlHQ = streamUrlHQ;
+          }
         }
         if (item.bio_image && opts.artistImageFormat) {
           artist.imageUrl = `${opts.imageBaseUrl}/img/${item.bio_image.image_id}_${opts.artistImageFormat.id}.jpg`;

src/lib/fan/FanWishlistParser.ts

@@ -75,18 +75,24 @@ export default class FanWishlistParser extends FanItemsBaseParser {
       const streamUrl = featuredTrackData.file?.['mp3-128'];
       const streamUrlHQ = featuredTrackData.file?.['mp3-v0'];
       if (mediaItemType === 'album') {
-        (mediaItem as Album).featuredTrack = {
+        const featuredTrack: Omit<Track, 'type'> = {
           position: featuredTrackData.track_number,
           name: featuredTrackData.title,
           artist: featuredTrackData.artist,
           duration,
-          streamUrl,
-          streamUrlHQ
+          streamUrl
         };
+        if (streamUrlHQ) {
+          featuredTrack.streamUrlHQ = streamUrlHQ;
+        }
+        (mediaItem as Album).featuredTrack = featuredTrack;
       }
       else {
         (mediaItem as Track).duration = duration;
         (mediaItem as Track).streamUrl = streamUrl;
+        if (streamUrlHQ) {
+          (mediaItem as Track).streamUrlHQ = streamUrlHQ;
+        }
       }
     }
     return mediaItem;

src/lib/tag/AlbumHighlightsByTagParser.ts

@@ -51,9 +51,12 @@ export default class AlbumHighlightsByTagParser {
               if (item.featured_track_title) {
                 album.featuredTrack = {
                   name: item.featured_track_title,
-                  streamUrl: item.audio_url?.['mp3-128'],
-                  streamUrlHQ: item.audio_url?.['mp3-v0']
+                  streamUrl: item.audio_url?.['mp3-128']
                 };
+                const streamUrlHQ = item.audio_url?.['mp3-v0'];
+                if (streamUrlHQ) {
+                  album.featuredTrack.streamUrlHQ = streamUrlHQ;
+                }
               }
               collectionRes.items.push(album);
             }

src/lib/tag/ReleasesByTagParser.ts

@@ -163,17 +163,24 @@ export default class ReleasesByTagParser {
           if (item.art_id && opts.imageFormat?.id) {
             mediaItem.imageUrl = `${opts.imageBaseUrl}/img/a${item.art_id}_${opts.imageFormat.id}.jpg`;
           }
+          const streamUrl = item.audio_url?.['mp3-128'];
+          const streamUrlHQ = item.audio_url?.['mp3-v0'];
           if (mediaItemType === 'album' && item.featured_track_title) {
             const album = mediaItem as Album;
             album.featuredTrack = {
               name: item.featured_track_title,
               position: item.featured_track_number,
-              streamUrl: item.audio_url?.['mp3-128'],
-              streamUrlHQ: item.audio_url?.['mp3-v0']
+              streamUrl
             };
+            if (streamUrlHQ) {
+              album.featuredTrack.streamUrlHQ = streamUrlHQ;
+            }
           }
           else if (mediaItemType === 'track') {
-            (mediaItem as Track).streamUrl = item.audio_url?.['mp3-128'];
+            (mediaItem as Track).streamUrl = streamUrl;
+            if (streamUrlHQ) {
+              (mediaItem as Track).streamUrlHQ = streamUrlHQ;
+            }
           }
           parsedItems.push(mediaItem);
         }