fix: relative performance with sorting

src/frontend/components/Standings/hooks/useDriverPositions.tsx

@@ -79,7 +79,7 @@ export const useDriverStandings = () => {
   const driverStandings: Standings[] = useMemo(() => {
     const standings = drivers.map((driver) => {
       const driverPos = driverPositions.find(
-        (driverPos) => driverPos.carIdx === driver.carIdx
+        (driverPos) => driverPos.carIdx === driver.carIdx,
       );
 
       if (!driverPos) return undefined;
@@ -99,7 +99,7 @@ export const useDriverStandings = () => {
       let classPosition: number | undefined = driverPos.classPosition;
       if (classPosition <= 0) {
         const qualifyingPosition = qualifyingPositions?.find(
-          (q) => q.CarIdx === driver.carIdx
+          (q) => q.CarIdx === driver.carIdx,
         );
         classPosition = qualifyingPosition ? qualifyingPosition.Position + 1 : undefined;
       }

src/frontend/components/Standings/hooks/useDriverRelatives.tsx

@@ -45,7 +45,7 @@ export const useDriverRelatives = ({ buffer }: { buffer: number }) => {
 
       const player = drivers.find((driver) => driver.carIdx === playerIndex);
       const other = drivers.find((driver) => driver.carIdx === otherCarIdx);
-      
+
       // Use the slower car's lap time for more conservative deltas in multiclass
       const playerEstLapTime = player?.carClass?.estLapTime ?? 0;
       const otherEstLapTime = other?.carClass?.estLapTime ?? 0;
@@ -64,38 +64,42 @@ export const useDriverRelatives = ({ buffer }: { buffer: number }) => {
       return timeDelta;
     };
 
-    const filterAndMapDrivers = () => {
-      return drivers
-        .filter((driver) => driver.onTrack || driver.carIdx === playerIndex) // filter out drivers not on track
-        .filter((driver) => driver.carIdx > -1 && driver.carIdx !== paceCarIdx) // filter out pace car
-        .map((result) => ({
-          ...result,
-          relativePct: calculateRelativePct(result.carIdx),
-        }))
-        .filter((result) => !isNaN(result.relativePct))
-        .sort((a, b) => b.relativePct - a.relativePct) // sort by relative pct
-        .map((result) => ({
+    const sortedDrivers = drivers
+      .filter((driver) => driver.onTrack || driver.carIdx === playerIndex) // filter out drivers not on track
+      .filter((driver) => driver.carIdx > -1 && driver.carIdx !== paceCarIdx) // filter out pace car
+      .map((result) => {
+        const relativePct = calculateRelativePct(result.carIdx);
+        return {
           ...result,
+          relativePct,
           delta: calculateDelta(result.carIdx),
-        }))
-        .filter((result) => !isNaN(result.delta));
-    };
+        };
+      })
+      .filter((result) => !isNaN(result.relativePct) && !isNaN(result.delta));
 
-    const allRelatives = filterAndMapDrivers();
-    const playerArrIndex = allRelatives.findIndex(
-      (result) => result.carIdx === playerIndex
+    const playerArrIndex = sortedDrivers.findIndex(
+      (result) => result.carIdx === playerIndex,
     );
 
     // if the player is not in the list, return an empty array
     if (playerArrIndex === -1) {
       return [];
     }
 
-    // buffered slice to get only the drivers around the player
-    const start = Math.max(0, playerArrIndex - buffer);
-    const end = Math.min(allRelatives.length, playerArrIndex + buffer + 1);
+    const player = sortedDrivers[playerArrIndex];
+
+    const driversAhead = sortedDrivers
+      .filter((d) => d.relativePct > 0)
+      .sort((a, b) => a.relativePct - b.relativePct) // sort ascending (closest to player first)
+      .slice(0, buffer)
+      .reverse(); // reverse to get furthest to closest for display
+
+    const driversBehind = sortedDrivers
+      .filter((d) => d.relativePct < 0)
+      .sort((a, b) => b.relativePct - a.relativePct) // sort descending (closest to player first)
+      .slice(0, buffer);
 
-    return allRelatives.slice(start, end);
+    return [...driversAhead, player, ...driversBehind];
   }, [buffer, playerIndex, carIdxLapDistPct, drivers, paceCarIdx]);
 
   return standings;