teslo/dist/index.d.ts

Elo rating system

declare class Player {
    id: string;
    elo: number;
    constructor(id: string, elo: number);
    static create(id: string, elo: number): Player;
    getExpectedResult(opponentElo: number): number;
    calculate(opponentElo: number, won: boolean, kFactor: number): number;
}

declare class Team {
    id: string;
    players: Map<string, Player>;
    constructor(id: string, players?: Player[]);
    static create(id: string, players?: Player[]): Team;
    addPlayer(player: Player): this;
    addPlayers(...players: Player[]): this;
    getAverageElo(): number;
}

interface Options {
    kFactor?: number;
    minContestants?: number;
    maxContestants?: number;
}

interface PlayerResult {
    id: string;
    elo: number;
}
interface TeamResult {
    id: string;
    players: PlayerResult[];
}
type Results = PlayerResult[] | TeamResult[];

type Contestant = Player | Team;
declare abstract class Match {
    private _contestants;
    private _completed;
    protected readonly minContestants: number;
    protected readonly maxContestants: number;
    protected readonly kFactor: number;
    constructor(options?: Options);
    get contestants(): Map<string, Contestant>;
    get size(): number;
    get completed(): boolean;
    protected set completed(completed: boolean);
    protected contestantMapToEloMap(): Map<string, number>;
    protected contestantMapToResults<T extends Results>(): T;
    protected findOpponentElos(contestantId: string, contestants: Map<string, number>): number[];
    protected addContestant(contestant: Contestant): void;
    getResults(): Results;
    abstract calculate(contestantIds: string | string[]): Results;
}

type DuelOptions = Partial<Pick<Options, 'kFactor'>>;
declare class Duel extends Match {
    constructor(players?: Player[], options?: DuelOptions);
    static create(players?: Player[], options?: DuelOptions): Duel;
    addPlayer(player: Player): this;
    addPlayers(...players: Player[]): this;
    calculate(playerId: string): PlayerResult[];
}

interface FreeForAllOptions extends Partial<Pick<Options, 'kFactor'>> {
    minPlayers?: number;
    maxPlayers?: number;
}
declare class FreeForAll extends Match {
    constructor(players?: Player[], options?: FreeForAllOptions);
    static create(players?: Player[], options?: FreeForAllOptions): FreeForAll;
    addPlayer(player: Player): this;
    addPlayers(...players: Player[]): this;
    calculate(playerIds: string[]): PlayerResult[];
}

type TeamDuelOptions = Partial<Pick<Options, 'kFactor'>>;
declare class TeamDuel extends Match {
    constructor(teams?: Team[], options?: TeamDuelOptions);
    static create(teams?: Team[], options?: TeamDuelOptions): TeamDuel;
    addTeam(team: Team): this;
    addTeams(...teams: Team[]): this;
    calculate(teamId: string): TeamResult[];
}

interface TeamFreeForAllOptions extends Partial<Pick<Options, 'kFactor'>> {
    minTeams?: number;
    maxTeams?: number;
}
declare class TeamFreeForAll extends Match {
    constructor(teams?: Team[], options?: TeamFreeForAllOptions);
    static create(teams?: Team[], options?: TeamFreeForAllOptions): TeamFreeForAll;
    addTeam(team: Team): this;
    addTeams(...teams: Team[]): this;
    calculate(teamIds: string[]): TeamResult[];
}

declare class BaseError<T extends string> extends Error {
    name: T;
    constructor(name: T, message: string);
}

declare const ERROR_NAME = "MATCH_ERROR";
declare const ErrorType: {
    MATCH_COMPLETE: string;
    MATCH_INCOMPLETE: string;
    MAX_PLAYERS: string;
    MIN_PLAYERS: string;
    MAX_TEAMS: string;
    MIN_TEAMS: string;
    SIZE_MISMATCH: string;
    PLAYER_NOT_FOUND: string;
    TEAM_NOT_FOUND: string;
    MISSING_OPPONENT_ELO: string;
};
type ErrorTypeKey = keyof typeof ErrorType;
declare class MatchError<T extends ErrorTypeKey> extends BaseError<typeof ERROR_NAME> {
    constructor(message: (typeof ErrorType)[T]);
}

export { Duel, ErrorType, FreeForAll, MatchError, Player, Team, TeamDuel, TeamFreeForAll };
export type { PlayerResult, Results, TeamResult };