add beatleader score fetching and add icons to FC

src/utils/beatleader/api.ts

@@ -0,0 +1,102 @@
+import { BeatleaderScore } from "@/schemas/beatleader/score";
+import { ssrSettings } from "@/ssrSettings";
+import { FetchQueue } from "../fetchWithQueue";
+import { formatString } from "../string";
+
+// Create a fetch instance with a cache
+const fetchQueue = new FetchQueue();
+
+// Api endpoints
+const API_URL = ssrSettings.proxy + "/https://api.beatleader.xyz";
+const PLAYER_SCORES_URL =
+  API_URL + "/player/{}/scores?sortBy=date&order=0&page={}&count=100";
+
+/**
+ * Get the players scores from the given page
+ *
+ * @param playerId the id of the player
+ * @param page the page to get the scores from
+ * @param searchType the type of search to perform
+ * @param limit the limit of scores to get
+ * @returns a list of scores
+ */
+async function fetchScores(
+  playerId: string,
+  page: number = 1,
+  limit: number = 100,
+): Promise<
+  | {
+      scores: BeatleaderScore[];
+      pageInfo: {
+        totalScores: number;
+        page: number;
+        totalPages: number;
+      };
+    }
+  | undefined
+> {
+  if (limit > 100) {
+    throw new Error("Limit cannot be greater than 100");
+  }
+
+  const response = await fetchQueue.fetch(
+    formatString(PLAYER_SCORES_URL, true, playerId, page),
+  );
+  const json = await response.json();
+
+  // Check if there was an error fetching the user data
+  console.log(json);
+
+  const metadata = json.metadata;
+  return {
+    scores: json.data as BeatleaderScore[],
+    pageInfo: {
+      totalScores: json.totalScores,
+      page: json.page,
+      totalPages: Math.ceil(json.totalScores / metadata.itemsPerPage),
+    },
+  };
+}
+
+/**
+ * Gets all of the players for the given player id
+ *
+ * @param playerId the id of the player
+ * @param searchType the type of search to perform
+ * @param callback a callback to call when a page is fetched
+ * @returns a list of scores
+ */
+async function fetchAllScores(
+  playerId: string,
+  callback?: (currentPage: number, totalPages: number) => void,
+): Promise<BeatleaderScore[] | undefined> {
+  const scores = new Array();
+
+  let done = false,
+    page = 1;
+  do {
+    const response = await fetchScores(playerId, page);
+    if (response == undefined) {
+      done = true;
+      break;
+    }
+    const { scores: scoresFetched } = response;
+    if (scoresFetched.length === 0) {
+      done = true;
+      break;
+    }
+    scores.push(...scoresFetched);
+
+    if (callback) {
+      callback(page, response.pageInfo.totalPages);
+    }
+    page++;
+  } while (!done);
+
+  return scores as BeatleaderScore[];
+}
+
+export const BeatLeaderAPI = {
+  fetchScores,
+  fetchAllScores,
+};

src/utils/fetchWithQueue.ts

@@ -25,7 +25,18 @@ export class FetchQueue {
 
     const response = await fetch(url);
     if (response.status === 429) {
-      const retryAfter = Number(response.headers.get("retry-after")) * 1000;
+      const hasRetryAfter = response.headers.has("retry-after");
+      let retryAfter =
+        Number(
+          hasRetryAfter
+            ? response.headers.get("retry-after")
+            : new Date(
+                response.headers.get("X-Rate-Limit-Reset") as string,
+              ).getTime() / 1000,
+        ) * 1000;
+      if (!retryAfter) {
+        retryAfter = 3_000; // default to 3 seconds if we can't get the reset time
+      }
       this._queue.push(url);
       await new Promise<void>((resolve) => setTimeout(resolve, retryAfter));
       return this.fetch(this._queue.shift() as string);

src/utils/scoresaber/api.ts

@@ -28,7 +28,7 @@ const SearchType = {
  * @param name the name to search
  * @returns a list of players
  */
-export async function searchByName(
+async function searchByName(
   name: string,
 ): Promise<ScoresaberPlayer[] | undefined> {
   const response = await fetchQueue.fetch(
@@ -50,7 +50,7 @@ export async function searchByName(
  * @param playerId the id of the player
  * @returns the player info
  */
-export async function getPlayerInfo(
+async function getPlayerInfo(
   playerId: string,
 ): Promise<ScoresaberPlayer | undefined | null> {
   const response = await fetchQueue.fetch(
@@ -75,7 +75,7 @@ export async function getPlayerInfo(
  * @param limit the limit of scores to get
  * @returns a list of scores
  */
-export async function fetchScores(
+async function fetchScores(
   playerId: string,
   page: number = 1,
   searchType: string = SearchType.RECENT,
@@ -92,10 +92,7 @@ export async function fetchScores(
   | undefined
 > {
   if (limit > 100) {
-    console.log(
-      "Scoresaber API only allows a limit of 100 scores per request, limiting to 100.",
-    );
-    limit = 100;
+    throw new Error("Limit cannot be greater than 100");
   }
   const response = await fetchQueue.fetch(
     formatString(PLAYER_SCORES, true, playerId, limit, searchType, page),
@@ -127,7 +124,7 @@ export async function fetchScores(
  * @param callback a callback to call when a page is fetched
  * @returns a list of scores
  */
-export async function fetchAllScores(
+async function fetchAllScores(
   playerId: string,
   searchType: string,
   callback?: (currentPage: number, totalPages: number) => void,
@@ -165,7 +162,7 @@ export async function fetchAllScores(
  * @param country the country to get the players from
  * @returns a list of players
  */
-export async function fetchTopPlayers(
+async function fetchTopPlayers(
   page: number = 1,
   country?: string,
 ): Promise<
@@ -201,3 +198,11 @@ export async function fetchTopPlayers(
     },
   };
 }
+
+export const ScoreSaberAPI = {
+  searchByName,
+  getPlayerInfo,
+  fetchScores,
+  fetchAllScores,
+  fetchTopPlayers,
+};

src/utils/scoresaber/scores.ts

@@ -1,7 +1,7 @@
 // Yoinked from https://github.com/Shurdoof/pp-calculator/blob/c24b5ca452119339928831d74e6d603fb17fd5ef/src/lib/pp/calculator.ts
 // Thank for for this I have no fucking idea what the maths is doing but it works!
 
-import { usePlayerScoresStore } from "@/store/playerScoresStore";
+import { useScoresaberScoresStore } from "@/store/scoresaberScoresStore";
 
 export const WEIGHT_COEFFICIENT = 0.965;
 
@@ -115,7 +115,7 @@ function calcRawPpAtIdx(
  * @returns the pp boundary (+ per raw pp)
  */
 export function calcPpBoundary(playerId: string, expectedPp = 1) {
-  const rankedScores = usePlayerScoresStore
+  const rankedScores = useScoresaberScoresStore
     .getState()
     .players.find((p) => p.id === playerId)
     ?.scores?.scoresaber.filter((s) => s.score.pp !== undefined);
@@ -156,7 +156,7 @@ export function calcPpBoundary(playerId: string, expectedPp = 1) {
  * @returns the highest pp play
  */
 export function getHighestPpPlay(playerId: string) {
-  const rankedScores = usePlayerScoresStore
+  const rankedScores = useScoresaberScoresStore
     .getState()
     .players.find((p) => p.id === playerId)
     ?.scores?.scoresaber.filter((s) => s.score.pp !== undefined);
@@ -176,7 +176,7 @@ export function getHighestPpPlay(playerId: string) {
  * @param limit the amount of top scores to average (default: 20)
  */
 export function getAveragePp(playerId: string, limit: number = 20) {
-  const rankedScores = usePlayerScoresStore
+  const rankedScores = useScoresaberScoresStore
     .getState()
     .players.find((p) => p.id === playerId)
     ?.scores?.scoresaber.filter((s) => s.score.pp !== undefined);