volleyballsimtypes 0.0.162 → 0.0.165

package/dist/esm/src/service/competition/iteration.d.ts

@@ -0,0 +1,10 @@
+interface IterationOpts {
+    readonly id: number;
+    readonly startDate: Date;
+}
+export declare class Iteration {
+    readonly id: number;
+    readonly startDate: Date;
+    constructor({ id, startDate }: IterationOpts);
+}
+export {};

package/dist/esm/src/service/competition/iteration.js

@@ -0,0 +1,8 @@
+export class Iteration {
+    constructor({ id, startDate }) {
+        if (id < 1)
+            throw new Error(`INVALID_ITERATION: ${id}`);
+        this.id = id;
+        this.startDate = startDate;
+    }
+}

package/dist/esm/src/service/competition/league.d.ts

@@ -0,0 +1,16 @@
+import { Season } from './season';
+import { Country } from '../country';
+interface LeagueOpts {
+    readonly id: string;
+    readonly name: string;
+    readonly country: Country;
+    readonly seasons: Season[];
+}
+export declare class League {
+    readonly id: string;
+    readonly name: string;
+    readonly seasons: Season[];
+    readonly country: Country;
+    constructor({ id, name, country, seasons }: LeagueOpts);
+}
+export {};

package/dist/esm/src/service/competition/league.js

@@ -0,0 +1,8 @@
+export class League {
+    constructor({ id, name, country, seasons }) {
+        this.id = id;
+        this.name = name;
+        this.country = country;
+        this.seasons = seasons;
+    }
+}

package/dist/esm/src/service/competition/season.d.ts

@@ -0,0 +1,26 @@
+import { Team } from '../team';
+import { Match } from '../match';
+import { Standing } from './standing';
+import { Iteration } from './iteration';
+import { StatusEnum } from '../../data';
+interface SeasonOpts {
+    readonly id: string;
+    readonly teams: Team[];
+    readonly matches: Match[];
+    readonly iteration: Iteration;
+    readonly champion?: Team;
+    readonly status: StatusEnum;
+}
+export declare class Season {
+    readonly id: string;
+    readonly teams: Team[];
+    readonly matches: Match[];
+    readonly iteration: Iteration;
+    readonly standings: Standing[];
+    readonly status: StatusEnum;
+    champion?: Team;
+    constructor({ id, iteration, teams, matches, champion, status }: SeasonOpts);
+    calculateStandings(): Standing[];
+    updateStandings(): void;
+}
+export {};

package/dist/esm/src/service/competition/season.js

@@ -0,0 +1,28 @@
+import { Standing } from './standing';
+export class Season {
+    constructor({ id, iteration, teams, matches, champion, status }) {
+        this.id = id;
+        this.teams = teams;
+        this.matches = matches;
+        this.iteration = iteration;
+        this.champion = champion;
+        this.standings = this.calculateStandings();
+        this.status = status;
+    }
+    calculateStandings() {
+        return this.teams.map(team => {
+            const standing = new Standing({ team });
+            standing.calculateStanding(this.matches);
+            return standing;
+        }).sort(Standing.sortFn);
+    }
+    updateStandings() {
+        if (this.matches == null || this.matches.length < 1)
+            throw new Error('NO_MATCHES');
+        this.standings.length = 0;
+        this.standings.push(...this.calculateStandings());
+        if (this.matches.every((match) => match.isOver())) {
+            this.champion = this.standings[0].team;
+        }
+    }
+}

package/dist/esm/src/service/competition/stage.d.ts

@@ -0,0 +1,11 @@
+export declare enum Stage {
+    ROUND_OF_8 = 8,
+    QUARTERFINALS = 4,
+    SEMIFINALS = 2,
+    FINAL = 1,
+    LEAGUE = 0
+}
+export declare namespace Stage {
+    function getStages(): Stage[];
+    function getNextStage(stage: Stage): Stage;
+}

package/dist/esm/src/service/competition/stage.js

@@ -0,0 +1,24 @@
+export var Stage;
+(function (Stage) {
+    Stage[Stage["ROUND_OF_8"] = 8] = "ROUND_OF_8";
+    Stage[Stage["QUARTERFINALS"] = 4] = "QUARTERFINALS";
+    Stage[Stage["SEMIFINALS"] = 2] = "SEMIFINALS";
+    Stage[Stage["FINAL"] = 1] = "FINAL";
+    Stage[Stage["LEAGUE"] = 0] = "LEAGUE";
+})(Stage || (Stage = {}));
+// eslint-disable-next-line @typescript-eslint/no-namespace
+(function (Stage) {
+    const STAGES = [Stage.ROUND_OF_8, Stage.QUARTERFINALS, Stage.SEMIFINALS, Stage.FINAL, Stage.LEAGUE];
+    function getStages() {
+        return [...STAGES];
+    }
+    Stage.getStages = getStages;
+    function getNextStage(stage) {
+        if (stage < 1)
+            throw new Error(`INVALID_STAGE ${stage}`);
+        if (stage === 1)
+            throw new Error('ALREADY_IN_FINAL_STAGE');
+        return stage / 2;
+    }
+    Stage.getNextStage = getNextStage;
+})(Stage || (Stage = {}));

package/dist/esm/src/service/competition/standing.d.ts

@@ -0,0 +1,28 @@
+import { Match } from '../match';
+import { Team } from '../team';
+interface StandingOpts {
+    readonly team: Team;
+}
+export declare class Standing {
+    readonly team: Team;
+    won30: number;
+    won31: number;
+    won32: number;
+    lost03: number;
+    lost13: number;
+    lost23: number;
+    pointsWon: number;
+    pointsLost: number;
+    points: number;
+    pointsRatio: number;
+    setsWon: number;
+    setsLost: number;
+    setsRatio: number;
+    matchesWon: number;
+    matchesLost: number;
+    totalMatches: number;
+    constructor({ team }: StandingOpts);
+    static sortFn(standingA: Standing, standingB: Standing): number;
+    calculateStanding(matches: Match[]): void;
+}
+export {};

package/dist/esm/src/service/competition/standing.js

@@ -0,0 +1,76 @@
+import { MatchTeam } from '../match';
+export class Standing {
+    constructor({ team }) {
+        this.won30 = 0;
+        this.won31 = 0;
+        this.won32 = 0;
+        this.lost03 = 0;
+        this.lost13 = 0;
+        this.lost23 = 0;
+        this.pointsWon = 0;
+        this.pointsLost = 0;
+        this.points = 0;
+        this.pointsRatio = 0;
+        this.setsWon = 0;
+        this.setsLost = 0;
+        this.setsRatio = 0;
+        this.matchesWon = 0;
+        this.matchesLost = 0;
+        this.totalMatches = 0;
+        this.team = team;
+    }
+    static sortFn(standingA, standingB) {
+        if (standingB.points > standingA.points)
+            return 1;
+        else if (standingA.points > standingB.points)
+            return -1;
+        else if (standingB.setsRatio > standingA.setsRatio)
+            return 1;
+        else if (standingA.setsRatio > standingB.setsRatio)
+            return -1;
+        else if (standingB.pointsRatio > standingA.pointsRatio)
+            return 1;
+        else if (standingA.pointsRatio > standingB.pointsRatio)
+            return -1;
+        else
+            return 0;
+    }
+    calculateStanding(matches) {
+        matches = matches.filter(match => match.homeTeam.id === this.team.id || match.awayTeam.id === this.team.id)
+            .filter(match => match.isOver());
+        let teamSide;
+        let otherSide;
+        let teamScore;
+        let otherScore;
+        for (const match of matches) {
+            if (this.team.id === match.homeTeam.id) {
+                teamSide = MatchTeam.HOME;
+                otherSide = MatchTeam.AWAY;
+            }
+            else {
+                teamSide = MatchTeam.AWAY;
+                otherSide = MatchTeam.HOME;
+            }
+            if (match.getWinner().id === this.team.id) {
+                this[`won3${match.getTeamSets(otherSide)}`]++;
+            }
+            else {
+                this[`lost${match.getTeamSets(teamSide)}3`]++;
+            }
+            teamScore = `${teamSide === MatchTeam.HOME ? 'home' : 'away'}Score`;
+            otherScore = `${otherSide === MatchTeam.HOME ? 'home' : 'away'}Score`;
+            for (const set of match.sets) {
+                this.pointsWon += set[teamScore];
+                this.pointsLost += set[otherScore];
+            }
+        }
+        this.points = (this.won30 + this.won31) * 3 + this.won32 * 2 + this.lost23;
+        this.pointsRatio = this.pointsWon / this.pointsLost;
+        this.setsWon = (this.won32 + this.won31 + this.won30) * 3 + this.lost23 * 2 + this.lost13;
+        this.setsLost = (this.lost03 + this.lost13 + this.lost23) * 3 + this.won32 * 2 + this.won31;
+        this.setsRatio = this.setsWon / this.setsLost;
+        this.matchesWon = this.won32 + this.won31 + this.won30;
+        this.matchesLost = this.lost03 + this.lost13 + this.lost23;
+        this.totalMatches = this.matchesWon + this.matchesLost;
+    }
+}

package/dist/esm/src/service/competition/tournament-match.d.ts

@@ -0,0 +1,14 @@
+import { Match } from '../match';
+import { Stage } from './stage';
+interface TournamentStageOpts {
+    readonly stage: Stage;
+    readonly match: Match;
+    readonly index: number;
+}
+export declare class TournamentMatch {
+    readonly stage: Stage;
+    readonly match: Match;
+    readonly index: number;
+    constructor({ stage, match, index }: TournamentStageOpts);
+}
+export {};

package/dist/esm/src/service/competition/tournament-match.js

@@ -0,0 +1,9 @@
+export class TournamentMatch {
+    constructor({ stage, match, index }) {
+        if (index > stage || index < 0)
+            throw new Error('INDEX_OUT_OF_BOUNDS');
+        this.stage = stage;
+        this.match = match;
+        this.index = index;
+    }
+}

package/dist/esm/src/service/competition/tournament.d.ts

@@ -0,0 +1,23 @@
+import { TournamentMatch } from './tournament-match';
+import { Team } from '../team';
+import { Iteration } from './iteration';
+import { StatusEnum } from '../../data';
+interface TournamentOpts {
+    readonly id: string;
+    readonly iteration: Iteration;
+    readonly matches: TournamentMatch[];
+    readonly teams: Team[];
+    readonly champion?: Team;
+    readonly status: StatusEnum;
+}
+export declare class Tournament {
+    readonly id: string;
+    readonly iteration: Iteration;
+    readonly matches: TournamentMatch[];
+    readonly teams: Team[];
+    readonly status: StatusEnum;
+    champion?: Team;
+    constructor({ id, iteration, matches, teams, champion, status }: TournamentOpts);
+    static sortMatchesFn(m1: TournamentMatch, m2: TournamentMatch): number;
+}
+export {};

package/dist/esm/src/service/competition/tournament.js

@@ -0,0 +1,19 @@
+export class Tournament {
+    constructor({ id, iteration, matches, teams, champion, status }) {
+        this.id = id;
+        this.iteration = iteration;
+        this.matches = matches;
+        this.teams = teams;
+        this.champion = champion;
+        this.status = status;
+        this.matches.sort(Tournament.sortMatchesFn);
+    }
+    static sortMatchesFn(m1, m2) {
+        if (m1.stage > m2.stage)
+            return -1;
+        else if (m1.stage < m2.stage)
+            return 1;
+        else
+            return m1.index - m2.index;
+    }
+}

package/dist/esm/src/service/country/country.d.ts

@@ -0,0 +1,17 @@
+interface CountryOpts {
+    readonly id: string;
+    readonly name: string;
+    readonly short: string;
+    readonly language?: string;
+    readonly league?: string;
+}
+export declare class Country {
+    readonly id: string;
+    readonly name: string;
+    readonly short: string;
+    readonly language?: string;
+    readonly league?: string;
+    constructor({ id, name, short, language, league }: CountryOpts);
+    toString(): string;
+}
+export {};

package/dist/esm/src/service/country/country.js

@@ -0,0 +1,18 @@
+export class Country {
+    constructor({ id, name, short, language, league }) {
+        this.id = id;
+        this.name = name;
+        this.short = short;
+        this.language = language;
+        this.league = league;
+    }
+    toString() {
+        return JSON.stringify({
+            id: this.id,
+            name: this.name,
+            short: this.short,
+            language: this.language,
+            league: this.league
+        });
+    }
+}

package/dist/esm/src/service/country/index.d.ts

@@ -0,0 +1 @@
+export * from './country';

package/dist/esm/src/service/country/index.js

@@ -0,0 +1 @@
+export * from './country';

package/dist/esm/src/service/draft/draft-pick.d.ts

@@ -0,0 +1,14 @@
+import { Team } from '../team';
+import { Player } from '../player';
+interface DraftPickOpts {
+    readonly team: Team;
+    readonly pick: Player;
+    readonly priority: number;
+}
+export declare class DraftPick {
+    readonly team: Team;
+    readonly pick: Player;
+    readonly priority: number;
+    constructor({ team, pick, priority }: DraftPickOpts);
+}
+export {};

package/dist/esm/src/service/draft/draft-pick.js

@@ -0,0 +1,7 @@
+export class DraftPick {
+    constructor({ team, pick, priority }) {
+        this.team = team;
+        this.pick = pick;
+        this.priority = priority;
+    }
+}

package/dist/esm/src/service/draft/draft.d.ts

@@ -0,0 +1,15 @@
+import { DraftPick } from './draft-pick';
+interface DraftParams {
+    readonly id: string;
+    readonly start: Date;
+    readonly end: Date;
+    readonly picks: DraftPick[];
+}
+export declare class Draft {
+    readonly id: string;
+    readonly start: Date;
+    readonly end: Date;
+    readonly picks: DraftPick[];
+    constructor({ id, start, end, picks }: DraftParams);
+}
+export {};

package/dist/esm/src/service/draft/draft.js

@@ -0,0 +1,8 @@
+export class Draft {
+    constructor({ id, start, end, picks }) {
+        this.id = id;
+        this.start = start;
+        this.end = end;
+        this.picks = picks;
+    }
+}

package/dist/esm/src/service/draft/index.d.ts

@@ -0,0 +1,2 @@
+export * from './draft';
+export * from './draft-pick';

package/dist/esm/src/service/draft/index.js

@@ -0,0 +1,2 @@
+export * from './draft';
+export * from './draft-pick';

package/dist/esm/src/service/event/index.d.ts

@@ -0,0 +1 @@
+export * from './rally-event';

package/dist/esm/src/service/event/index.js

@@ -0,0 +1 @@
+export * from './rally-event';

package/dist/esm/src/service/event/rally-event.d.ts

@@ -0,0 +1,11 @@
+import { EventTypeEnum } from '../../data';
+export interface RallyEventOpts {
+    readonly player: string;
+    readonly eventType: EventTypeEnum;
+}
+export declare abstract class RallyEvent {
+    readonly player: string;
+    readonly eventType: EventTypeEnum;
+    protected constructor({ eventType, player }: RallyEventOpts);
+    abstract toString(): string;
+}

package/dist/esm/src/service/event/rally-event.js

@@ -0,0 +1,6 @@
+export class RallyEvent {
+    constructor({ eventType, player }) {
+        this.player = player;
+        this.eventType = eventType;
+    }
+}

package/dist/esm/src/service/index.d.ts

@@ -0,0 +1,9 @@
+export * from './match';
+export * from './coach';
+export * from './country';
+export * from './draft';
+export * from './team';
+export * from './event';
+export * from './player';
+export * from './competition';
+export * from './utils';

package/dist/esm/src/service/index.js

@@ -0,0 +1,9 @@
+export * from './match';
+export * from './coach';
+export * from './country';
+export * from './draft';
+export * from './team';
+export * from './event';
+export * from './player';
+export * from './competition';
+export * from './utils';

package/dist/esm/src/service/match/court-position.d.ts

@@ -0,0 +1,34 @@
+export declare enum CourtRow {
+    BACK = "BACK_ROW",
+    FRONT = "FRONT_ROW"
+}
+export declare enum CourtPosition {
+    NOT_IN_COURT = -1,
+    LIBERO_ZONE = 0,
+    LEFT_FRONT = 4,
+    MIDDLE_FRONT = 3,
+    RIGHT_FRONT = 2,
+    LEFT_BACK = 5,
+    MIDDLE_BACK = 6,
+    RIGHT_BACK = 1
+}
+export declare enum CourtTarget {
+    NO_TARGET = 0,
+    OPPONENT_RIGHT_BACK = 7,
+    OPPONENT_MIDDLE_BACK = 12,
+    OPPONENT_LEFT_BACK = 11,
+    OPPONENT_RIGHT_FRONT = 8,
+    OPPONENT_MIDDLE_FRONT = 9,
+    OPPONENT_LEFT_FRONT = 10,
+    TEAM_LEFT_FRONT = 4,
+    TEAM_MIDDLE_FRONT = 3,
+    TEAM_RIGHT_FRONT = 2,
+    TEAM_LEFT_BACK = 5,
+    TEAM_MIDDLE_BACK = 6,
+    TEAM_RIGHT_BACK = 1
+}
+export declare function getPositions(): CourtPosition[];
+export declare function rotatePosition(position: number): CourtPosition;
+export declare function isFrontRow(position: number): boolean;
+export declare function isBackRow(position: number): boolean;
+export declare function getCourtRow(row: CourtRow): CourtPosition[];

package/dist/esm/src/service/match/court-position.js

@@ -0,0 +1,62 @@
+export var CourtRow;
+(function (CourtRow) {
+    CourtRow["BACK"] = "BACK_ROW";
+    CourtRow["FRONT"] = "FRONT_ROW";
+})(CourtRow || (CourtRow = {}));
+export var CourtPosition;
+(function (CourtPosition) {
+    CourtPosition[CourtPosition["NOT_IN_COURT"] = -1] = "NOT_IN_COURT";
+    CourtPosition[CourtPosition["LIBERO_ZONE"] = 0] = "LIBERO_ZONE";
+    // -----------------------------------------------------
+    CourtPosition[CourtPosition["LEFT_FRONT"] = 4] = "LEFT_FRONT";
+    CourtPosition[CourtPosition["MIDDLE_FRONT"] = 3] = "MIDDLE_FRONT";
+    CourtPosition[CourtPosition["RIGHT_FRONT"] = 2] = "RIGHT_FRONT";
+    CourtPosition[CourtPosition["LEFT_BACK"] = 5] = "LEFT_BACK";
+    CourtPosition[CourtPosition["MIDDLE_BACK"] = 6] = "MIDDLE_BACK";
+    CourtPosition[CourtPosition["RIGHT_BACK"] = 1] = "RIGHT_BACK";
+})(CourtPosition || (CourtPosition = {}));
+export var CourtTarget;
+(function (CourtTarget) {
+    CourtTarget[CourtTarget["NO_TARGET"] = 0] = "NO_TARGET";
+    CourtTarget[CourtTarget["OPPONENT_RIGHT_BACK"] = 7] = "OPPONENT_RIGHT_BACK";
+    CourtTarget[CourtTarget["OPPONENT_MIDDLE_BACK"] = 12] = "OPPONENT_MIDDLE_BACK";
+    CourtTarget[CourtTarget["OPPONENT_LEFT_BACK"] = 11] = "OPPONENT_LEFT_BACK";
+    CourtTarget[CourtTarget["OPPONENT_RIGHT_FRONT"] = 8] = "OPPONENT_RIGHT_FRONT";
+    CourtTarget[CourtTarget["OPPONENT_MIDDLE_FRONT"] = 9] = "OPPONENT_MIDDLE_FRONT";
+    CourtTarget[CourtTarget["OPPONENT_LEFT_FRONT"] = 10] = "OPPONENT_LEFT_FRONT";
+    // --------------------------------------------------------------------------------
+    CourtTarget[CourtTarget["TEAM_LEFT_FRONT"] = 4] = "TEAM_LEFT_FRONT";
+    CourtTarget[CourtTarget["TEAM_MIDDLE_FRONT"] = 3] = "TEAM_MIDDLE_FRONT";
+    CourtTarget[CourtTarget["TEAM_RIGHT_FRONT"] = 2] = "TEAM_RIGHT_FRONT";
+    CourtTarget[CourtTarget["TEAM_LEFT_BACK"] = 5] = "TEAM_LEFT_BACK";
+    CourtTarget[CourtTarget["TEAM_MIDDLE_BACK"] = 6] = "TEAM_MIDDLE_BACK";
+    CourtTarget[CourtTarget["TEAM_RIGHT_BACK"] = 1] = "TEAM_RIGHT_BACK";
+})(CourtTarget || (CourtTarget = {}));
+const FRONT_ROW = [CourtPosition.LEFT_FRONT, CourtPosition.MIDDLE_FRONT, CourtPosition.RIGHT_FRONT];
+const BACK_ROW = [CourtPosition.LEFT_BACK, CourtPosition.MIDDLE_BACK, CourtPosition.RIGHT_BACK];
+export function getPositions() {
+    return [...BACK_ROW, ...FRONT_ROW];
+}
+export function rotatePosition(position) {
+    if (position < 1 || position > 6)
+        throw new Error('POSITION_INDEX_OUT_OF_BOUNDS');
+    if (position > CourtPosition.RIGHT_BACK)
+        return position - 1;
+    else
+        return CourtPosition.MIDDLE_BACK;
+}
+export function isFrontRow(position) {
+    if (position < 1 || position > 6)
+        throw new Error('POSITION_INDEX_OUT_OF_BOUNDS');
+    return FRONT_ROW.includes(position);
+}
+export function isBackRow(position) {
+    if (position < 1 || position > 6)
+        throw new Error(`POSITION_INDEX_OUT_OF_BOUNDS: ${position}`);
+    return BACK_ROW.includes(position);
+}
+export function getCourtRow(row) {
+    if (![CourtRow.BACK, CourtRow.FRONT].includes(row))
+        throw new Error(`INVALID_ROW: ${row}`);
+    return CourtRow.BACK === row ? [...BACK_ROW] : [...FRONT_ROW];
+}

package/dist/esm/src/service/match/index.d.ts

@@ -0,0 +1,6 @@
+export * from './match';
+export * from './match-rating';
+export * from './match-set';
+export * from './rally';
+export * from './court-position';
+export * from './match-team';

package/dist/esm/src/service/match/index.js

@@ -0,0 +1,6 @@
+export * from './match';
+export * from './match-rating';
+export * from './match-set';
+export * from './rally';
+export * from './court-position';
+export * from './match-team';

package/dist/esm/src/service/match/match-rating.d.ts

@@ -0,0 +1,35 @@
+import { Match, MatchTeam } from '.';
+import { CompetitionType } from '../../data';
+interface MatchRatingParams {
+    readonly match: Match;
+    readonly competitionType: CompetitionType;
+}
+interface SetScoreVariant {
+    '3-0': number;
+    '3-1': number;
+    '3-2': number;
+    '2-3': number;
+    '1-3': number;
+    '0-3': number;
+}
+interface MatchWeightFactor {
+    TOURNAMENT: number;
+    LEAGUE: number;
+}
+export declare class MatchRating {
+    static K: number;
+    static SSV: SetScoreVariant;
+    static C1: number;
+    static C2: number;
+    static C3: number;
+    static C4: number;
+    static C5: number;
+    static MWF: MatchWeightFactor;
+    readonly match: Match;
+    readonly weight: number;
+    constructor({ match, competitionType }: MatchRatingParams);
+    getPoints(team: MatchTeam): number;
+    static calculateProbability(z: number): number;
+    getExpectedResult(): number;
+}
+export {};