Add sorting by disc number and track number

Author: alexesprit

messages/en.json

@@ -31,6 +31,8 @@
   "album": "Album",
   "release_date": "Release Date",
   "track_title": "Track Title",
+  "disc_number": "Disc Number",
+  "track_number": "Track Number",
   "ascending": "Ascending",
   "descending": "Descending",
   "no_rules_applied": "No rules applied yet",

messages/es.json

@@ -30,6 +30,8 @@
   "album": "Álbum",
   "release_date": "Fecha de Lanzamiento",
   "track_title": "Título de la Pista",
+  "disc_number": "Número de Disco",
+  "track_number": "Número de Pista",
   "ascending": "Ascendente",
   "descending": "Descendente",
   "no_rules_applied": "Aún no se aplicaron reglas",

src/features/sorting/utils/sortRules.test.ts

@@ -180,12 +180,21 @@ describe('getSortKeyName', () => {
   })
 
   test('should handle all sort keys', () => {
-    const sortKeys: SortKey[] = ['artist', 'album', 'release_date', 'title']
+    const sortKeys: SortKey[] = [
+      'artist',
+      'album',
+      'release_date',
+      'title',
+      'disc_number',
+      'track_number',
+    ]
     const expectedNames: Record<SortKey, string> = {
       artist: 'Artist',
       album: 'Album',
       release_date: 'Release Date',
       title: 'Track Title',
+      disc_number: 'Disc Number',
+      track_number: 'Track Number',
     }
 
     sortKeys.forEach((key) => {

src/features/sorting/utils/sortRules.ts

@@ -1,7 +1,13 @@
 /**
  * Sort key type.
  */
-export type SortKey = 'artist' | 'title' | 'album' | 'release_date'
+export type SortKey =
+  | 'artist'
+  | 'title'
+  | 'album'
+  | 'release_date'
+  | 'disc_number'
+  | 'track_number'
 
 /**
  * Sort oder type.
@@ -23,6 +29,8 @@ export const SORT_KEY_LABELS: Record<SortKey, string> = {
   album: m.album(),
   release_date: m.release_date(),
   title: m.track_title(),
+  disc_number: m.disc_number(),
+  track_number: m.track_number(),
 }
 
 /**
@@ -62,6 +70,10 @@ function getSortKeyLabel(sortKey: SortKey): string {
       return m.release_date()
     case 'title':
       return m.track_title()
+    case 'disc_number':
+      return m.disc_number()
+    case 'track_number':
+      return m.track_number()
     default:
       return sortKey
   }
@@ -83,7 +95,14 @@ export function getSortKeyName(sortKey: SortKey): string {
 const sortRuleSeparator = ' '
 const sortKeyOrderSeparator = '/'
 
-const validSortKeys = ['artist', 'album', 'release_date', 'title'] as const
+const validSortKeys = [
+  'artist',
+  'album',
+  'release_date',
+  'title',
+  'disc_number',
+  'track_number',
+] as const
 const validSortOrders: SortOrder[] = ['asc', 'desc']
 
 const defaultSortOrder: SortOrder = 'asc'

src/features/sorting/utils/sortTracks.test.ts

@@ -7,6 +7,8 @@ function createTrack(
   artistName: string,
   albumName: string | null = 'Test Album',
   releaseDate: string | null = '2024-01-01',
+  discNumber: number = 1,
+  trackNumber: number = 1,
   id = Math.random().toString(36).substring(7),
 ): SpotifyApi.PlaylistTrackObject {
   return {
@@ -67,8 +69,8 @@ function createTrack(
       external_urls: { spotify: '' },
       type: 'track',
       popularity: 50,
-      track_number: 1,
-      disc_number: 1,
+      track_number: trackNumber,
+      disc_number: discNumber,
       preview_url: null,
       available_markets: [],
       is_playable: true,
@@ -83,6 +85,8 @@ function createTrack(
 function createMultiArtistTrack(
   name: string,
   artistNames: string[],
+  discNumber: number = 1,
+  trackNumber: number = 1,
 ): SpotifyApi.PlaylistTrackObject {
   return {
     added_at: '2023-01-01',
@@ -140,8 +144,8 @@ function createMultiArtistTrack(
       external_urls: { spotify: '' },
       type: 'track',
       popularity: 50,
-      track_number: 1,
-      disc_number: 1,
+      track_number: trackNumber,
+      disc_number: discNumber,
       preview_url: null,
       available_markets: [],
       is_playable: true,
@@ -338,6 +342,94 @@ describe('sortTracks', () => {
         ).toBe('2020-05-15')
       })
     })
+
+    describe('disc_number sorting', () => {
+      test('should sort by disc_number ascending', () => {
+        const tracks = [
+          createTrack('Song 1', 'Artist', 'Album', '2024-01-01', 2, 1),
+          createTrack('Song 2', 'Artist', 'Album', '2024-01-01', 1, 1),
+          createTrack('Song 3', 'Artist', 'Album', '2024-01-01', 3, 1),
+        ]
+
+        const sortRules: SortRule[] = [['disc_number', 'asc']]
+        sortTracks(tracks, sortRules)
+
+        expect(
+          (tracks[0]?.track as SpotifyApi.TrackObjectFull).disc_number,
+        ).toBe(1)
+        expect(
+          (tracks[1]?.track as SpotifyApi.TrackObjectFull).disc_number,
+        ).toBe(2)
+        expect(
+          (tracks[2]?.track as SpotifyApi.TrackObjectFull).disc_number,
+        ).toBe(3)
+      })
+
+      test('should sort by disc_number descending', () => {
+        const tracks = [
+          createTrack('Song 1', 'Artist', 'Album', '2024-01-01', 1, 1),
+          createTrack('Song 2', 'Artist', 'Album', '2024-01-01', 2, 1),
+          createTrack('Song 3', 'Artist', 'Album', '2024-01-01', 3, 1),
+        ]
+
+        const sortRules: SortRule[] = [['disc_number', 'desc']]
+        sortTracks(tracks, sortRules)
+
+        expect(
+          (tracks[0]?.track as SpotifyApi.TrackObjectFull).disc_number,
+        ).toBe(3)
+        expect(
+          (tracks[1]?.track as SpotifyApi.TrackObjectFull).disc_number,
+        ).toBe(2)
+        expect(
+          (tracks[2]?.track as SpotifyApi.TrackObjectFull).disc_number,
+        ).toBe(1)
+      })
+    })
+
+    describe('track_number sorting', () => {
+      test('should sort by track_number ascending', () => {
+        const tracks = [
+          createTrack('Song 3', 'Artist', 'Album', '2024-01-01', 1, 3),
+          createTrack('Song 1', 'Artist', 'Album', '2024-01-01', 1, 1),
+          createTrack('Song 2', 'Artist', 'Album', '2024-01-01', 1, 2),
+        ]
+
+        const sortRules: SortRule[] = [['track_number', 'asc']]
+        sortTracks(tracks, sortRules)
+
+        expect(
+          (tracks[0]?.track as SpotifyApi.TrackObjectFull).track_number,
+        ).toBe(1)
+        expect(
+          (tracks[1]?.track as SpotifyApi.TrackObjectFull).track_number,
+        ).toBe(2)
+        expect(
+          (tracks[2]?.track as SpotifyApi.TrackObjectFull).track_number,
+        ).toBe(3)
+      })
+
+      test('should sort by track_number descending', () => {
+        const tracks = [
+          createTrack('Song 1', 'Artist', 'Album', '2024-01-01', 1, 1),
+          createTrack('Song 2', 'Artist', 'Album', '2024-01-01', 1, 2),
+          createTrack('Song 3', 'Artist', 'Album', '2024-01-01', 1, 3),
+        ]
+
+        const sortRules: SortRule[] = [['track_number', 'desc']]
+        sortTracks(tracks, sortRules)
+
+        expect(
+          (tracks[0]?.track as SpotifyApi.TrackObjectFull).track_number,
+        ).toBe(3)
+        expect(
+          (tracks[1]?.track as SpotifyApi.TrackObjectFull).track_number,
+        ).toBe(2)
+        expect(
+          (tracks[2]?.track as SpotifyApi.TrackObjectFull).track_number,
+        ).toBe(1)
+      })
+    })
   })
 
   describe('multi-rule sorting', () => {

src/features/sorting/utils/sortTracks.ts

@@ -2,7 +2,9 @@ import type { SortKey, SortRule } from '@/features/sorting/utils/sortRules'
 import {
   getAlbumName,
   getArtistName,
+  getDiscNumber,
   getReleaseDate,
+  getTrackNumber,
   getTrackTitle,
 } from '@/features/sorting/utils/trackTypeGuards'
 
@@ -15,6 +17,8 @@ const rulesCompareFunctions: Record<SortKey, CompareFunction> = {
   title: compareTitles,
   album: compareAlbums,
   release_date: compareReleaseDates,
+  disc_number: compareDiscNumbers,
+  track_number: compareTrackNumbers,
 }
 
 export function sortTracks(
@@ -64,6 +68,24 @@ function compareTitles(trackA: PlaylistTrack, trackB: PlaylistTrack): number {
   return compareStrings(getTrackTitle(trackA), getTrackTitle(trackB))
 }
 
+function compareDiscNumbers(
+  trackA: PlaylistTrack,
+  trackB: PlaylistTrack,
+): number {
+  const discA = getDiscNumber(trackA)
+  const discB = getDiscNumber(trackB)
+  return discA - discB
+}
+
+function compareTrackNumbers(
+  trackA: PlaylistTrack,
+  trackB: PlaylistTrack,
+): number {
+  const trackNumA = getTrackNumber(trackA)
+  const trackNumB = getTrackNumber(trackB)
+  return trackNumA - trackNumB
+}
+
 function compareStrings(str1: string, str2: string): number {
   if (!str1) {
     return -1

src/features/sorting/utils/trackTypeGuards.ts

@@ -66,3 +66,21 @@ export function getArtistName(track: PlaylistTrack): string {
 export function getTrackTitle(track: PlaylistTrack): string {
   return track.track?.name ?? ''
 }
+
+/**
+ * Safely extract disc number from a track
+ * @returns Disc number or 0 if not available
+ */
+export function getDiscNumber(track: PlaylistTrack): number {
+  const trackInfo = track.track as SpotifyApi.TrackObjectFull
+  return trackInfo.disc_number ?? 0
+}
+
+/**
+ * Safely extract track number from a track
+ * @returns Track number or 0 if not available
+ */
+export function getTrackNumber(track: PlaylistTrack): number {
+  const trackInfo = track.track as SpotifyApi.TrackObjectFull
+  return trackInfo.track_number ?? 0
+}