remove duplicates

client/src/components/LeaderboardSection.jsx

@@ -13,9 +13,10 @@ const LeaderboardSection = ({ title, leaderboards }) => {
 
   if (!leaderboards || leaderboards.length === 0) return null;
 
-  const displayedLeaderboards = showAll
-    ? leaderboards
-    : leaderboards.slice(0, ITEMS_PER_PAGE);
+  // On affiche toujours les 3 premiers
+  const displayedLeaderboards = leaderboards.slice(0, ITEMS_PER_PAGE);
+  // Le reste sera dans le Collapse
+  const remainingLeaderboards = leaderboards.slice(ITEMS_PER_PAGE);
 
   const toggleExpanded = () => {
     setShowAll(!showAll);
@@ -121,9 +122,9 @@ const LeaderboardSection = ({ title, leaderboards }) => {
           </Grid>
         ))}
       </Grid>
-      <Collapse in={showAll} timeout={300}>
+      <Collapse in={showAll} timeout={300} unmountOnExit>
         <Grid container spacing={3} sx={{ mt: 0 }}>
-          {leaderboards.slice(ITEMS_PER_PAGE).map((leaderboard, index) => (
+          {remainingLeaderboards.map((leaderboard, index) => (
             <Grid item xs={12} sm={6} md={4} key={index + ITEMS_PER_PAGE}>
               <LeaderboardCard leaderboard={leaderboard} />
             </Grid>

client/src/context/LeaderboardContext.jsx

@@ -57,166 +57,206 @@ export const LeaderboardProvider = ({ children }) => {
     );
   }, []);
 
-  const filterUncategorized = useCallback((boards) => {
-    const categorizedTags = [
-      "eval:code",
-      "eval:math",
-      "eval:safety",
-      "modality:video",
-      "modality:image",
-      "modality:audio",
-      "modality:agent",
-      "domain:financial",
-      "domain:medical",
-      "domain:legal",
-    ];
+  // Filter leaderboards based on search query and arena toggle
+  const filterLeaderboards = useCallback(
+    (boards) => {
+      if (!boards) return [];
 
-    return (
-      boards?.filter((board) => {
-        if (!board.tags || board.tags.length === 0) {
-          return true;
-        }
+      // On évite de créer une copie inutile
+      let filtered = boards;
+
+      // Filter by search query
+      if (searchQuery) {
+        const query = searchQuery.toLowerCase();
+        const searchableTagPrefixes = [
+          "domain:",
+          "language:",
+          "judge:",
+          "test:",
+          "modality:",
+          "submission:",
+          "domain:",
+          "eval:",
+        ];
 
-        const hasNoTagsInCategory = !board.tags?.some(
-          (tag) => categorizedTags.includes(tag) || tag.startsWith("language:")
+        filtered = filtered.filter((board) => {
+          const isTagSearch = searchableTagPrefixes.some((prefix) =>
+            query.startsWith(prefix)
+          );
+
+          if (isTagSearch) {
+            return board.tags?.some((tag) => tag.toLowerCase().includes(query));
+          }
+
+          return board.card_data?.title?.toLowerCase().includes(query);
+        });
+      }
+
+      // Filter arena only
+      if (arenaOnly) {
+        filtered = filtered.filter((board) =>
+          board.tags?.includes("judge:humans")
         );
+      }
 
-        return hasNoTagsInCategory;
-      }) || []
-    );
-  }, []);
+      return filtered;
+    },
+    [searchQuery, arenaOnly]
+  );
 
   // Define sections
   const allSections = useMemo(() => {
     if (!leaderboards) return [];
 
-    return [
+    // D'abord filtrer les leaderboards selon la recherche
+    const filteredBoards = filterLeaderboards(leaderboards);
+
+    // Garder une trace des leaderboards déjà catégorisés
+    const categorizedIds = new Set();
+
+    const sections = [
       {
         id: "agentic",
         title: "Agentic",
-        data: filterByTag("modality:agent", leaderboards),
+        data: filterByTag("modality:agent", filteredBoards).map((board) => {
+          categorizedIds.add(board.id);
+          return board;
+        }),
       },
       {
         id: "code",
         title: "Code",
-        data: filterByTag("eval:code", leaderboards),
+        data: filterByTag("eval:code", filteredBoards).map((board) => {
+          categorizedIds.add(board.id);
+          return board;
+        }),
       },
       {
         id: "math",
         title: "Math",
-        data: filterByTag("eval:math", leaderboards),
+        data: filterByTag("eval:math", filteredBoards).map((board) => {
+          categorizedIds.add(board.id);
+          return board;
+        }),
       },
       {
         id: "language",
         title: "Language Specific",
-        data: filterByLanguage(leaderboards),
+        data: filterByLanguage(filteredBoards).map((board) => {
+          categorizedIds.add(board.id);
+          return board;
+        }),
+      },
+      {
+        id: "vision",
+        title: "Vision",
+        data: filterByVision(filteredBoards).map((board) => {
+          categorizedIds.add(board.id);
+          return board;
+        }),
       },
-      { id: "vision", title: "Vision", data: filterByVision(leaderboards) },
       {
         id: "audio",
         title: "Audio",
-        data: filterByTag("modality:audio", leaderboards),
+        data: filterByTag("modality:audio", filteredBoards).map((board) => {
+          categorizedIds.add(board.id);
+          return board;
+        }),
       },
       {
         id: "financial",
         title: "Financial",
-        data: filterByTag("domain:financial", leaderboards),
+        data: filterByTag("domain:financial", filteredBoards).map((board) => {
+          categorizedIds.add(board.id);
+          return board;
+        }),
       },
       {
         id: "medical",
         title: "Medical",
-        data: filterByTag("domain:medical", leaderboards),
+        data: filterByTag("domain:medical", filteredBoards).map((board) => {
+          categorizedIds.add(board.id);
+          return board;
+        }),
       },
       {
         id: "legal",
         title: "Legal",
-        data: filterByTag("domain:legal", leaderboards),
+        data: filterByTag("domain:legal", filteredBoards).map((board) => {
+          categorizedIds.add(board.id);
+          return board;
+        }),
       },
       {
         id: "safety",
         title: "Safety",
-        data: filterByTag("eval:safety", leaderboards),
+        data: filterByTag("eval:safety", filteredBoards).map((board) => {
+          categorizedIds.add(board.id);
+          return board;
+        }),
       },
       {
         id: "uncategorized",
         title: "Uncategorized",
-        data: filterUncategorized(leaderboards),
+        // Mettre dans uncategorized uniquement les leaderboards qui n'apparaissent nulle part ailleurs
+        data: filteredBoards.filter((board) => !categorizedIds.has(board.id)),
       },
     ];
+
+    return sections;
   }, [
     leaderboards,
+    filterLeaderboards,
     filterByTag,
     filterByLanguage,
     filterByVision,
-    filterUncategorized,
   ]);
 
   // Get sections with data
   const sections = useMemo(() => {
+    console.log("Starting sections filtering...");
+    console.log(
+      "All sections before filtering:",
+      allSections.map((s) => ({
+        title: s.title,
+        count: s.data.length,
+        ids: s.data.map((b) => b.id),
+      }))
+    );
+
+    // On garde une trace des titres déjà vus
+    const seenTitles = new Set();
     const filteredSections = allSections.filter((section) => {
-      console.log(`Section ${section.title}:`, {
+      console.log(`\nAnalyzing section ${section.title}:`, {
         data: section.data,
         count: section.data.length,
+        uniqueIds: new Set(section.data.map((b) => b.id)).size,
         boards: section.data.map((board) => ({
           id: board.id,
           tags: board.tags,
         })),
       });
-      return section.data.length > 0;
+
+      // On garde la section si elle a des données et qu'on ne l'a pas déjà vue
+      if (section.data.length > 0 && !seenTitles.has(section.title)) {
+        seenTitles.add(section.title);
+        return true;
+      }
+      return false;
     });
+
     console.log(
-      "Final sections:",
-      filteredSections.map((s) => s.title)
+      "\nFinal sections after filtering:",
+      filteredSections.map((s) => ({
+        title: s.title,
+        count: s.data.length,
+        uniqueIds: new Set(s.data.map((b) => b.id)).size,
+      }))
     );
+
     return filteredSections;
   }, [allSections]);
 
-  // Filter leaderboards based on search query and arena toggle
-  const filterLeaderboards = useCallback(
-    (boards) => {
-      if (!boards) return [];
-
-      let filtered = [...boards];
-
-      // Filter by search query
-      if (searchQuery) {
-        const query = searchQuery.toLowerCase();
-        const searchableTagPrefixes = [
-          "domain:",
-          "language:",
-          "judge:",
-          "test:",
-          "modality:",
-          "submission:",
-          "domain:",
-          "eval:",
-        ];
-
-        filtered = filtered.filter((board) => {
-          const isTagSearch = searchableTagPrefixes.some((prefix) =>
-            query.startsWith(prefix)
-          );
-
-          if (isTagSearch) {
-            return board.tags?.some((tag) => tag.toLowerCase().includes(query));
-          }
-
-          return board.card_data?.title?.toLowerCase().includes(query);
-        });
-      }
-
-      // Filter arena only
-      if (arenaOnly) {
-        filtered = filtered.filter((board) =>
-          board.tags?.includes("judge:humans")
-        );
-      }
-
-      return filtered;
-    },
-    [searchQuery, arenaOnly]
-  );
-
   // Get filtered count
   const filteredCount = useMemo(() => {
     return filterLeaderboards(leaderboards).length;