Top days

src/components/LookUp.vue

···
 const loading = ref(false);
 const artists = ref<{ name: string; plays: number }[]>([]);
 const tracks = ref<{ name: string; artist: string; plays: number }[]>([]);
+const topDays = ref<{ date: string; plays: number }[]>([]);
 const totalSongs = ref(0);
 
 const formatNumber = (n: number) => n.toLocaleString();
+
+// Returns YYYY-MM-DD in the browser's local time zone
+const localDayKey = (iso?: string): string | null => {
+    if (!iso) return null;
+    const d = new Date(iso);
+    if (isNaN(d.getTime())) return null;
+    const y = d.getFullYear();
+    const m = (d.getMonth() + 1).toString().padStart(2, "0");
+    const day = d.getDate().toString().padStart(2, "0");
+    return `${y}-${m}-${day}`;
+};
 
 const lookup = async () => {
     loading.value = true;
···
         let totalCount = 0;
         let inner_tracks: { name: string; artist: string; plays: number }[] = [];
         let inner_artists: { name: string; plays: number }[] = [];
+        const dayCountMap = new Map<string, number>();
 
         let response = await agent.com.atproto.repo.listRecords({
             repo: did,
···
                 ) {
                     continue;
                 }
-                // new version of lexicon
+                // Aggregate by artist(s)
                 if (play.value?.artists) {
                     for (const artist of play.value?.artists) {
                         let alreadyPlayed = inner_artists.find(
···
                                 plays: 1,
                             });
                         } else {
-                            console.log(`Artist already played: ${alreadyPlayed}`);
                             alreadyPlayed.plays++;
                         }
                     }
···
                     }
                 }
 
+                // Aggregate by track
                 let alreadyPlayed = inner_tracks.find(
                     (a) => a.name === play.value.trackName,
                 );
···
                 } else if (alreadyPlayed) {
                     alreadyPlayed.plays++;
                 }
+
+                // Aggregate by local day using playedTime
+                const key = localDayKey(play.value?.playedTime);
+                if (key) {
+                    dayCountMap.set(key, (dayCountMap.get(key) ?? 0) + 1);
+                }
             }
 
-            // update reactive values incrementally (top 10)
+            // update reactive values incrementally (top 25)
             artists.value = inner_artists
                 .sort((a, b) => b.plays - a.plays)
                 .slice(0, 25);
···
                 .slice(0, 25);
             totalSongs.value = totalCount;
 
+            // compute top 25 days
+            topDays.value = Array.from(dayCountMap.entries())
+                .map(([date, plays]) => ({ date, plays }))
+                .sort((a, b) => b.plays - a.plays)
+                .slice(0, 25);
+
             cursor = response.data.cursor;
             if (!cursor) break;
 
···
                                 <td>{{ idx + 1 }}.</td>
                                 <td>{{ formatNumber(artist.plays) }}</td>
                                 <td>{{ artist.name }}</td>
+                            </tr>
+                        </tbody>
+                    </table>
+                </div>
+            </div>
+            <div v-if="topDays.length > 0" class="mt-8">
+                <h2 class="text-2xl font-bold mb-4">Top Days (Most Songs Played)</h2>
+                <div class="overflow-x-auto">
+                    <table class="table w-full">
+                        <thead>
+                            <tr>
+                                <th>Rank</th>
+                                <th>Plays</th>
+                                <th>Date (yyyy-mm-dd)</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr v-for="(day, idx) in topDays" :key="day.date">
+                                <td>{{ idx + 1 }}.</td>
+                                <td>{{ formatNumber(day.plays) }}</td>
+                                <td>{{ day.date }}</td>
                             </tr>
                         </tbody>
                     </table>