feat: aggregate multiple reposts to avoid duplicate posts in feed

src/components/NoteList/index.tsx

@@ -1,11 +1,12 @@
 import NewNotesButton from '@/components/NewNotesButton'
 import { Button } from '@/components/ui/button'
 import {
-  getReplaceableCoordinateFromEvent,
+  getEventKey,
+  getEventKeyFromTag,
   isMentioningMutedUsers,
-  isReplaceableEvent,
   isReplyNoteEvent
 } from '@/lib/event'
+import { tagNameEquals } from '@/lib/tag'
 import { isTouchDevice } from '@/lib/utils'
 import { useContentPolicy } from '@/providers/ContentPolicyProvider'
 import { useDeletedEvent } from '@/providers/DeletedEventProvider'
@@ -15,7 +16,7 @@ import { useUserTrust } from '@/providers/UserTrustProvider'
 import client from '@/services/client.service'
 import { TFeedSubRequest } from '@/types'
 import dayjs from 'dayjs'
-import { Event } from 'nostr-tools'
+import { Event, kinds, verifyEvent } from 'nostr-tools'
 import { decode } from 'nostr-tools/nip19'
 import {
   forwardRef,
@@ -113,34 +114,95 @@ const NoteList = forwardRef(
       [hideReplies, hideUntrustedNotes, mutePubkeySet, pinnedEventIds, isEventDeleted, filterFn]
     )
 
-    const filteredEvents = useMemo(() => {
-      const idSet = new Set<string>()
+    const filteredNotes = useMemo(() => {
+      // Store processed event keys to avoid duplicates
+      const keySet = new Set<string>()
+      // Map to track reposters for each event key
+      const repostersMap = new Map<string, Set<string>>()
+      // Final list of filtered events
+      const filteredEvents: Event[] = []
 
-      return events.slice(0, showCount).filter((evt) => {
-        if (shouldHideEvent(evt)) return false
+      events.slice(0, showCount).forEach((evt) => {
+        const key = getEventKey(evt)
+        if (keySet.has(key)) return
+        keySet.add(key)
 
-        const id = isReplaceableEvent(evt.kind) ? getReplaceableCoordinateFromEvent(evt) : evt.id
-        if (idSet.has(id)) {
-          return false
+        if (shouldHideEvent(evt)) return
+        if (evt.kind !== kinds.Repost) {
+          filteredEvents.push(evt)
+          return
         }
-        idSet.add(id)
-        return true
+
+        const eventFromContent = evt.content ? (JSON.parse(evt.content) as Event) : null
+        if (eventFromContent && verifyEvent(eventFromContent)) {
+          if (eventFromContent.kind === kinds.Repost) {
+            return
+          }
+          if (shouldHideEvent(eventFromContent)) return
+
+          client.addEventToCache(eventFromContent)
+          const targetSeenOn = client.getSeenEventRelays(eventFromContent.id)
+          if (targetSeenOn.length === 0) {
+            const seenOn = client.getSeenEventRelays(evt.id)
+            seenOn.forEach((relay) => {
+              client.trackEventSeenOn(eventFromContent.id, relay)
+            })
+          }
+
+          const targetEventKey = getEventKey(eventFromContent)
+          const reposters = repostersMap.get(targetEventKey)
+          if (reposters) {
+            reposters.add(evt.pubkey)
+          } else {
+            repostersMap.set(targetEventKey, new Set([evt.pubkey]))
+          }
+          // If the target event is not already included, add it now
+          if (!keySet.has(targetEventKey)) {
+            filteredEvents.push(eventFromContent)
+            keySet.add(targetEventKey)
+          }
+          return
+        }
+
+        const targetTag = evt.tags.find(tagNameEquals('a')) ?? evt.tags.find(tagNameEquals('e'))
+        if (targetTag) {
+          const targetEventKey = getEventKeyFromTag(targetTag)
+          if (targetEventKey) {
+            // Add to reposters map
+            const reposters = repostersMap.get(targetEventKey)
+            if (reposters) {
+              reposters.add(evt.pubkey)
+            } else {
+              repostersMap.set(targetEventKey, new Set([evt.pubkey]))
+            }
+            // If the target event is already included, skip adding this repost
+            if (keySet.has(targetEventKey)) {
+              return
+            }
+          }
+        }
+        // If we can't find the original event, just show the repost itself
+        filteredEvents.push(evt)
+        return
+      })
+
+      return filteredEvents.map((evt) => {
+        const key = getEventKey(evt)
+        return { key, event: evt, reposters: Array.from(repostersMap.get(key) ?? []) }
       })
     }, [events, showCount, shouldHideEvent])
 
     const filteredNewEvents = useMemo(() => {
-      const idSet = new Set<string>()
+      const keySet = new Set<string>()
 
       return newEvents.filter((event: Event) => {
         if (shouldHideEvent(event)) return false
 
-        const id = isReplaceableEvent(event.kind)
-          ? getReplaceableCoordinateFromEvent(event)
-          : event.id
-        if (idSet.has(id)) {
+        const key = getEventKey(event)
+        if (keySet.has(key)) {
           return false
         }
-        idSet.add(id)
+        keySet.add(key)
         return true
       })
     }, [newEvents, shouldHideEvent])
@@ -306,12 +368,13 @@ const NoteList = forwardRef(
         {pinnedEventIds.map((id) => (
           <PinnedNoteCard key={id} eventId={id} className="w-full" />
         ))}
-        {filteredEvents.map((event) => (
+        {filteredNotes.map(({ key, event, reposters }) => (
           <NoteCard
-            key={event.id}
+            key={key}
             className="w-full"
             event={event}
             filterMutedNotes={filterMutedNotes}
+            reposters={reposters}
           />
         ))}
         {hasMore || loading ? (