add minimum drivers to display to standings

Author: tariknz

src/frontend/components/Standings/createStandings.spec.ts

@@ -315,6 +315,8 @@ describe('createStandings', () => {
 
       const filteredDrivers = sliceRelevantDrivers(results, 'GT3');
 
+      expect(filteredDrivers[0][1]).toHaveLength(10);
+
       expect(filteredDrivers).toEqual([
         [
           'GT3',
@@ -326,10 +328,88 @@ describe('createStandings', () => {
             { name: '5. David' },
             { name: '6. Sebastian' },
             { name: '7. Nico' },
+            { name: '8. Eve' },
+            { name: '9. Frank' },
+            { name: '10. Max' },
           ],
         ],
       ]);
     });
+
+    it('should return at least 10 drivers if available', () => {
+      const results: [string, DummyStanding[]][] = [
+        [
+          'GT3',
+          [
+            { name: '1. Bob' },
+            { name: '2. Alice' },
+            { name: '3. Charlie' },
+            { name: '4. David' },
+            { name: '5. Eve' },
+            { name: '6. Frank' },
+            { name: '7. Player', isPlayer: true },
+            { name: '8. Hannah' },
+            { name: '9. Irene' },
+            { name: '10. Jack' },
+            { name: '11. Kevin' },
+          ],
+        ],
+      ];
+      const filteredDrivers = sliceRelevantDrivers(results, 'GT3');
+      expect(filteredDrivers[0][1].length).toBe(10);
+    });
+
+    it('should allow minPlayerClassDrivers to be configured', () => {
+      const results: [string, DummyStanding[]][] = [
+        [
+          'GT3',
+          [
+            { name: '1. Bob' },
+            { name: '2. Alice' },
+            { name: '3. Charlie' },
+            { name: '4. David' },
+            { name: '5. Eve' },
+            { name: '6. Frank' },
+            { name: '7. Player', isPlayer: true },
+            { name: '8. Hannah' },
+            { name: '9. Irene' },
+            { name: '10. Jack' },
+            { name: '11. Kevin' },
+          ],
+        ],
+      ];
+      const filteredDrivers = sliceRelevantDrivers(results, 'GT3', {
+        minPlayerClassDrivers: 5,
+      });
+      expect(filteredDrivers[0][1].length).toBe(10);
+    });
+
+    it('should allow numTopDrivers to be configured', () => {
+      const results: [string, DummyStanding[]][] = [
+        [
+          'GT3',
+          [
+            { name: '1. Bob' },
+            { name: '2. Alice' },
+            { name: '3. Charlie' },
+            { name: '4. David' },
+            { name: '5. Eve' },
+            { name: '6. Frank' },
+            { name: '7. Player', isPlayer: true },
+            { name: '8. Hannah' },
+            { name: '9. Irene' },
+            { name: '10. Jack' },
+            { name: '11. Kevin' },
+          ],
+        ],
+      ];
+      const filteredDrivers = sliceRelevantDrivers(results, 'GT3', {
+        numTopDrivers: 1,
+      });
+      expect(filteredDrivers[0][1].length).toBe(9);
+      expect(filteredDrivers[0][1][0].name).toBe('1. Bob');
+      expect(filteredDrivers[0][1][1].name).toBe('4. David');
+    });
   });
 });
 
@@ -347,6 +427,8 @@ function createStandings(
   options?: {
     buffer?: number;
     numNonClassDrivers?: number;
+    minPlayerClassDrivers?: number;
+    numTopDrivers?: number;
   }
 ) {
   const standings = createDriverStandings(

src/frontend/components/Standings/createStandings.ts

@@ -202,50 +202,69 @@ export const augmentStandingsWithIRating = (
  * @param driverClass - The class of the player
  * @param options.buffer - The number of drivers to include before and after the player
  * @param options.numNonClassDrivers - The number of drivers to include in classes outside of the player's class
+ * @param options.minPlayerClassDrivers - The minimum number of drivers to include in the player's class
+ * @param options.numTopDrivers - The number of top drivers to always include in the player's class
  * @returns The sliced standings
  */
 export const sliceRelevantDrivers = <T extends { isPlayer?: boolean }>(
   groupedStandings: [string, T[]][],
   driverClass: string | number | undefined,
-  { buffer = 3, numNonClassDrivers = 3 } = {}
+  {
+    buffer = 3,
+    numNonClassDrivers = 3,
+    minPlayerClassDrivers = 10,
+    numTopDrivers = 3,
+  } = {}
 ): [string, T[]][] => {
-  // this is honestly a bit too complicated to maintain so after some testing will
-  // probably simplify it so its a bit more readable
   return groupedStandings.map(([classIdx, standings]) => {
     const playerIndex = standings.findIndex((driver) => driver.isPlayer);
     if (String(driverClass) !== classIdx) {
-      // if player is not in this class, return only top 3 drivers in that class
+      // if player is not in this class, return only top N drivers in that class
       return [classIdx, standings.slice(0, numNonClassDrivers)];
     }
 
-    // if there are less than 10 drivers, return all
-    if (standings.length <= 10) return [classIdx, standings];
+    // if there are less than minPlayerClassDrivers drivers, return all of them
+    if (standings.length <= minPlayerClassDrivers) {
+      return [classIdx, standings];
+    }
 
-    // take the player and a buffer of drivers before and after the player
-    const start = Math.max(playerIndex - buffer, 0);
-    let end = Math.min(playerIndex + buffer + 1, standings.length);
+    // when no player is found, just return the top `minPlayerClassDrivers`
+    if (playerIndex === -1) {
+      return [classIdx, standings.slice(0, minPlayerClassDrivers)];
+    }
 
-    if (playerIndex <= 3) {
-      // if player is in top 3, include more drivers at the end
-      end = Math.min(
-        playerIndex + buffer + 3 - playerIndex + 1,
-        standings.length
-      );
+    const relevantDrivers = new Set<T>();
+
+    // Add top drivers
+    for (let i = 0; i < numTopDrivers; i++) {
+      if (standings[i]) {
+        relevantDrivers.add(standings[i]);
+      }
     }
 
-    const sliced = standings.slice(start, end);
-
-    if (playerIndex > 3) {
-      // add back top 3 but don't include overlapping indexes
-      // reverse to add in correct order when doing array unshift
-      standings
-        .slice(0, 3)
-        .reverse()
-        .forEach((driver) => {
-          if (!sliced.includes(driver)) sliced.unshift(driver);
-        });
+    // Add drivers around the player
+    const start = Math.max(0, playerIndex - buffer);
+    const end = Math.min(standings.length, playerIndex + buffer + 1);
+    for (let i = start; i < end; i++) {
+      if (standings[i]) {
+        relevantDrivers.add(standings[i]);
+      }
+    }
+
+    // Ensure we have at least `minPlayerClassDrivers`
+    let lastIndex = end;
+    while (
+      relevantDrivers.size < minPlayerClassDrivers &&
+      lastIndex < standings.length
+    ) {
+      relevantDrivers.add(standings[lastIndex]);
+      lastIndex++;
     }
 
-    return [classIdx, sliced];
+    const sortedDrivers = [...relevantDrivers].sort(
+      (a, b) => standings.indexOf(a) - standings.indexOf(b)
+    );
+
+    return [classIdx, sortedDrivers];
   });
 };