Refactor helpers

Author: Drarig29

src/helpers.ts

@@ -13,29 +13,11 @@ export function splitBy<T>(array: T[], key: keyof T): T[][] {
     return Object.values(obj);
 }
 
-interface Ranking {
-    [prop: string]: number,
-    rank: number,
-    id: number,
-    played: number,
-    wins: number,
-    draws: number,
-    losses: number,
-    forfeits: number,
-    scoreFor: number,
-    scoreAgainst: number,
-    scoreDifference: number,
-    points: number,
-}
-
-interface Header {
-    value: string,
-    tooltip: string,
+export function isMajorRound(roundNumber: number) {
+    return roundNumber === 1 || roundNumber % 2 === 0;
 }
 
-type Headers = { [name in keyof Ranking]: Header };
-
-const headers: Headers = {
+const headers: RankingHeaders = {
     'rank': {
         value: '#',
         tooltip: 'Rank',
@@ -82,78 +64,78 @@ const headers: Headers = {
     },
 }
 
-export function isMajorRound(roundNumber: number) {
-    return roundNumber === 1 || roundNumber % 2 === 0;
-}
-
-export function rankingHeader(name: keyof Ranking): Header {
+export function rankingHeader(name: keyof RankingItem): Header {
     return headers[name];
 }
 
-export function getRanking(matches: Match[], pointsFormula?: (ranking: Ranking) => number): Ranking[] {
-    const teams: { [id: number]: Ranking } = {};
-
-    function processTeam(current: ParticipantResult | null, other: ParticipantResult | null) {
-        if (!current || current.id === null) return;
+export function getRanking(matches: Match[], formula?: RankingFormula): Ranking {
+    formula = formula || (
+        (item: RankingItem) => 3 * item.wins + 1 * item.draws + 0 * item.losses
+    );
 
-        const state = teams[current.id] || {
-            rank: 0,
-            id: 0,
-            played: 0,
-            wins: 0,
-            draws: 0,
-            losses: 0,
-            forfeits: 0,
-            scoreFor: 0,
-            scoreAgainst: 0,
-            scoreDifference: 0,
-            points: 0,
-        };
+    const rankingMap: RankingMap = {};
 
-        state.id = current.id;
-        state.played++;
+    for (const match of matches) {
+        processTeam(rankingMap, formula, match.opponent1, match.opponent2);
+        processTeam(rankingMap, formula, match.opponent2, match.opponent1);
+    }
 
-        if (current.result === 'win')
-            state.wins++;
+    return createRanking(rankingMap);
+}
 
-        if (current.result === 'draw')
-            state.draws++;
+function createRanking(rankingMap: RankingMap) {
+    const ranking = Object.values(rankingMap).sort((a, b) => b.points - a.points);
+    
+    const rank = {
+        value: 0,
+        lastPoints: -1,
+    };
 
-        if (current.result === 'loss')
-            state.losses++;
+    for (const item of ranking) {
+        item.rank = rank.lastPoints !== item.points ? ++rank.value : rank.value;
+        rank.lastPoints = item.points;
+    }
 
-        if (current.forfeit)
-            state.forfeits++;
+    return ranking;
+}
 
-        state.scoreFor += current.score || 0;
-        state.scoreAgainst += other && other.score || 0;
-        state.scoreDifference = state.scoreFor - state.scoreAgainst;
+function processTeam(rankingMap: RankingMap, formula: RankingFormula, current: ParticipantResult | null, other: ParticipantResult | null) {
+    if (!current || current.id === null) return;
+
+    const state = rankingMap[current.id] || {
+        rank: 0,
+        id: 0,
+        played: 0,
+        wins: 0,
+        draws: 0,
+        losses: 0,
+        forfeits: 0,
+        scoreFor: 0,
+        scoreAgainst: 0,
+        scoreDifference: 0,
+        points: 0,
+    };
 
-        const formula = pointsFormula || (
-            (ranking: Ranking) => 3 * ranking.wins + 1 * ranking.draws + 0 * ranking.losses
-        );
+    state.id = current.id;
+    state.played++;
 
-        state.points = formula(state);
+    if (current.result === 'win')
+        state.wins++;
 
-        teams[current.id] = state;
-    }
+    if (current.result === 'draw')
+        state.draws++;
 
-    for (const match of matches) {
-        processTeam(match.opponent1, match.opponent2);
-        processTeam(match.opponent2, match.opponent1);
-    }
+    if (current.result === 'loss')
+        state.losses++;
 
-    const rankings = Object.values(teams).sort((a, b) => b.points - a.points);
+    if (current.forfeit)
+        state.forfeits++;
 
-    let rank = {
-        value: 0,
-        lastPoints: -1,
-    };
+    state.scoreFor += current.score || 0;
+    state.scoreAgainst += other && other.score || 0;
+    state.scoreDifference = state.scoreFor - state.scoreAgainst;
 
-    for (const ranking of rankings) {
-        ranking.rank = rank.lastPoints !== ranking.points ? ++rank.value : rank.value;
-        rank.lastPoints = ranking.points;
-    }
+    state.points = formula(state);
 
-    return rankings;
+    rankingMap[current.id] = state;
 }

src/main.ts

@@ -2,35 +2,6 @@ import './style.scss';
 import { Participant, Match, MatchResults, ParticipantResult, ViewerData } from "brackets-model";
 import { splitBy, getRanking, rankingHeader, isMajorRound } from "./helpers";
 
-type ConnectionType = 'square' | 'straight' | false;
-type Placement = 'none' | 'before' | 'after';
-type FinalType = 'consolation_final' | 'grand_final';
-type MatchHint = ((i: number) => string) | undefined;
-
-interface Connection {
-    connectPrevious?: ConnectionType,
-    connectNext?: ConnectionType,
-}
-
-interface Config {
-    /**
-     * Where the position of a participant is placed relative to its name.
-     * - If `before`, the position is prepended before the team name. "#1 Team"
-     * - If `after`, the position is appended after the team name, in parentheses. "Team (#1)"
-     */
-    participantOriginPlacement: Placement,
-
-    /**
-     * Whether to show the origin of a slot (wherever possible).
-     */
-    showSlotsOrigin: boolean,
-
-    /**
-     * Whether to show the origin of a slot (in the lower bracket of an elimination stage).
-     */
-    showLowerBracketSlotsOrigin: boolean,
-}
-
 class BracketsViewer {
 
     readonly teamRefsDOM: { [key: number]: HTMLElement[] } = {};

src/types.d.ts

@@ -0,0 +1,53 @@
+type ConnectionType = 'square' | 'straight' | false;
+type Placement = 'none' | 'before' | 'after';
+type FinalType = 'consolation_final' | 'grand_final';
+type MatchHint = ((i: number) => string) | undefined;
+
+interface Connection {
+    connectPrevious?: ConnectionType,
+    connectNext?: ConnectionType,
+}
+
+interface Config {
+    /**
+     * Where the position of a participant is placed relative to its name.
+     * - If `before`, the position is prepended before the team name. "#1 Team"
+     * - If `after`, the position is appended after the team name, in parentheses. "Team (#1)"
+     */
+    participantOriginPlacement: Placement,
+
+    /**
+     * Whether to show the origin of a slot (wherever possible).
+     */
+    showSlotsOrigin: boolean,
+
+    /**
+     * Whether to show the origin of a slot (in the lower bracket of an elimination stage).
+     */
+    showLowerBracketSlotsOrigin: boolean,
+}
+
+interface RankingItem {
+    [prop: string]: number,
+    rank: number,
+    id: number,
+    played: number,
+    wins: number,
+    draws: number,
+    losses: number,
+    forfeits: number,
+    scoreFor: number,
+    scoreAgainst: number,
+    scoreDifference: number,
+    points: number,
+}
+
+interface Header {
+    value: string,
+    tooltip: string,
+}
+
+type RankingFormula = (ranking: RankingItem) => number;
+type RankingHeaders = { [name in keyof RankingItem]: Header };
+type RankingMap = { [id: number]: RankingItem };
+type Ranking = RankingItem[];