volleyballsimtypes 0.0.7 → 0.0.9

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

@@ -0,0 +1,26 @@
+import { Match } from '../match';
+export interface StandingOpts {
+    readonly teamId: string;
+}
+export declare class Standing {
+    readonly teamId: string;
+    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({ teamId }: StandingOpts);
+    calculateStanding(matches: Match[]): void;
+    static sortFn(standingA: Standing, standingB: Standing): number;
+}

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

@@ -0,0 +1,76 @@
+import { MatchTeam } from '../match';
+export class Standing {
+    constructor({ teamId }) {
+        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.teamId = teamId;
+    }
+    calculateStanding(matches) {
+        matches = matches.filter(match => match.homeTeam.id === this.teamId || match.awayTeam.id === this.teamId)
+            .filter(match => match.isOver());
+        let teamSide;
+        let otherSide;
+        let teamScore;
+        let otherScore;
+        for (const match of matches) {
+            if (this.teamId === match.homeTeam.id) {
+                teamSide = MatchTeam.HOME;
+                otherSide = MatchTeam.AWAY;
+            }
+            else {
+                teamSide = MatchTeam.AWAY;
+                otherSide = MatchTeam.HOME;
+            }
+            if (match.getWinner().id === this.teamId) {
+                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;
+    }
+    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;
+    }
+}

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

@@ -0,0 +1,11 @@
+import { Rally } from '../rally';
+import { MatchSet } from '../match-set';
+import { Match } from '../match';
+import { Team } from '../../team';
+export declare const newRally: Rally;
+export declare const newSet: MatchSet;
+export declare const finishedSet: MatchSet;
+export declare const inProgressSet: MatchSet;
+export declare const teams: Team[];
+export declare const match: Match;
+export declare const match2: Match;

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

@@ -0,0 +1,113 @@
+import { Rally } from '../rally';
+import { MatchSet } from '../match-set';
+import { MatchTeam } from '../match-team';
+import { team } from '../../team/__stubs__';
+import { libero, rosters } from '../../player/__stubs__';
+import { Match } from '../match';
+import { Team } from '../../team';
+import { coaches } from '../../coach/__stubs__';
+import { country } from '../../country/__stubs__';
+export const newRally = new Rally({
+    servingTeam: team,
+    events: [],
+    order: 1,
+    id: '0ac3ba3a-d710-42dc-a1e7-7066b8df5fd9',
+    homePlayerPosition: [],
+    awayPlayerPosition: []
+});
+export const newSet = new MatchSet({
+    id: 'bf337ec2-9fee-495e-8d5a-d834b307d537',
+    stats: [],
+    rallies: [],
+    order: 0,
+    homeScore: 0,
+    awayScore: 0,
+    isTieBreak: false,
+    homeLibero: libero,
+    awayLibero: libero
+});
+export const finishedSet = (() => {
+    const set = new MatchSet({
+        id: 'c959fcf6-873f-4eae-80aa-a820e25329c4',
+        stats: [],
+        rallies: [],
+        order: 0,
+        homeScore: 0,
+        awayScore: 0,
+        isTieBreak: false,
+        homeLibero: libero,
+        awayLibero: libero
+    });
+    set.nextState();
+    for (let i = 0; i < 25; i++) {
+        set.increaseScore(MatchTeam.HOME);
+    }
+    set.nextState();
+    return set;
+})();
+export const inProgressSet = (() => {
+    const set = new MatchSet({
+        id: 'c1095b6c-9e70-4f9d-9942-d54aaa8655d0',
+        stats: [],
+        rallies: [],
+        order: 0,
+        homeScore: 0,
+        awayScore: 0,
+        isTieBreak: false,
+        homeLibero: libero,
+        awayLibero: libero
+    });
+    set.nextState();
+    for (let i = 0; i < 20; i++) {
+        set.increaseScore(MatchTeam.AWAY);
+    }
+    return set;
+})();
+export const teams = [
+    new Team({
+        id: '334ca929-6e71-4011-a2f0-5ca4fa83dbe5',
+        name: 'Jaloo',
+        shortName: 'JAL',
+        country,
+        roster: rosters[0],
+        coach: coaches[0]
+    }),
+    new Team({
+        id: 'f244d62d-f0ec-4005-8eb2-d955b0b8b191',
+        name: 'Fatz',
+        shortName: 'FAT',
+        country,
+        roster: rosters[1],
+        coach: coaches[1]
+    }),
+    new Team({
+        id: '749a5755-5c8b-4b07-aca9-1365a26c9a2e',
+        name: 'Tagtune',
+        shortName: 'TAG',
+        country,
+        roster: rosters[2],
+        coach: coaches[2]
+    }),
+    new Team({
+        id: 'd3dd532d-4898-44a3-853f-25f6fbdb3534',
+        name: 'Gigabox',
+        shortName: 'GIG',
+        country,
+        roster: rosters[3],
+        coach: coaches[3]
+    })
+];
+export const match = new Match({
+    id: '59aa2ea0-cf71-4081-b817-48dfdd454841',
+    homeTeam: teams[0],
+    awayTeam: teams[1],
+    sets: [],
+    scheduledDate: new Date('2023-07-26T21:48:12.273Z')
+});
+export const match2 = new Match({
+    id: 'dfd87bdc-20c2-4383-92ea-b5c36a8ba7aa',
+    homeTeam: teams[2],
+    awayTeam: teams[3],
+    sets: [],
+    scheduledDate: new Date('2023-07-26T21:48:12.273Z')
+});

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

@@ -0,0 +1,21 @@
+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 namespace CourtPosition {
+    function getPositions(): CourtPosition[];
+    function rotatePosition(position: number): CourtPosition;
+    function isFrontRow(position: number): boolean;
+    function isBackRow(position: number): boolean;
+    function getRow(row: CourtRow): CourtPosition[];
+}

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

@@ -0,0 +1,53 @@
+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 = {}));
+// eslint-disable-next-line @typescript-eslint/no-namespace
+(function (CourtPosition) {
+    const FRONT_ROW = [CourtPosition.LEFT_FRONT, CourtPosition.MIDDLE_FRONT, CourtPosition.RIGHT_FRONT];
+    const BACK_ROW = [CourtPosition.LEFT_BACK, CourtPosition.MIDDLE_BACK, CourtPosition.RIGHT_BACK];
+    function getPositions() {
+        return [...BACK_ROW, ...FRONT_ROW];
+    }
+    CourtPosition.getPositions = getPositions;
+    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;
+    }
+    CourtPosition.rotatePosition = rotatePosition;
+    function isFrontRow(position) {
+        if (position < 1 || position > 6)
+            throw new Error('POSITION_INDEX_OUT_OF_BOUNDS');
+        return FRONT_ROW.includes(position);
+    }
+    CourtPosition.isFrontRow = isFrontRow;
+    function isBackRow(position) {
+        if (position < 1 || position > 6)
+            throw new Error(`POSITION_INDEX_OUT_OF_BOUNDS: ${position}`);
+        return BACK_ROW.includes(position);
+    }
+    CourtPosition.isBackRow = isBackRow;
+    function getRow(row) {
+        if (![CourtRow.BACK, CourtRow.FRONT].includes(row))
+            throw new Error(`INVALID_ROW: ${row}`);
+        return CourtRow.BACK === row ? [...BACK_ROW] : [...FRONT_ROW];
+    }
+    CourtPosition.getRow = getRow;
+})(CourtPosition || (CourtPosition = {}));

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,67 @@
+import { describe, expect, test } from '@jest/globals';
+import { CourtPosition, CourtRow } from './court-position';
+describe('CourtPosition Test Module', () => {
+    const positions = [CourtPosition.LEFT_BACK, CourtPosition.MIDDLE_BACK, CourtPosition.RIGHT_BACK,
+        CourtPosition.LEFT_FRONT, CourtPosition.MIDDLE_FRONT, CourtPosition.RIGHT_FRONT];
+    // getPositions Tests
+    test('Should get all positions', () => {
+        expect(CourtPosition.getPositions()).toEqual(positions);
+    });
+    // rotatePosition Tests
+    test('Should return correct positions for rotation', () => {
+        expect(CourtPosition.rotatePosition(1)).toEqual(CourtPosition.MIDDLE_BACK);
+        expect(CourtPosition.rotatePosition(2)).toEqual(CourtPosition.RIGHT_BACK);
+        expect(CourtPosition.rotatePosition(3)).toEqual(CourtPosition.RIGHT_FRONT);
+        expect(CourtPosition.rotatePosition(4)).toEqual(CourtPosition.MIDDLE_FRONT);
+        expect(CourtPosition.rotatePosition(5)).toEqual(CourtPosition.LEFT_FRONT);
+        expect(CourtPosition.rotatePosition(6)).toEqual(CourtPosition.LEFT_BACK);
+    });
+    test('Should throw Error when rotating an invalid position', () => {
+        function rotate() { CourtPosition.rotatePosition(0); }
+        expect(rotate).toThrow(/^POSITION_INDEX_OUT_OF_BOUNDS$/);
+    });
+    // isFrontRow Tests
+    test('Should return true for front-row positions', () => {
+        expect(CourtPosition.isFrontRow(CourtPosition.LEFT_FRONT)).toEqual(true);
+        expect(CourtPosition.isFrontRow(CourtPosition.MIDDLE_FRONT)).toEqual(true);
+        expect(CourtPosition.isFrontRow(CourtPosition.RIGHT_FRONT)).toEqual(true);
+    });
+    test('Should return false for back-row positions', () => {
+        expect(CourtPosition.isFrontRow(CourtPosition.LEFT_BACK)).toEqual(false);
+        expect(CourtPosition.isFrontRow(CourtPosition.MIDDLE_BACK)).toEqual(false);
+        expect(CourtPosition.isFrontRow(CourtPosition.RIGHT_BACK)).toEqual(false);
+    });
+    test('Should throw Error providing an invalid position', () => {
+        function front() { CourtPosition.isFrontRow(0); }
+        expect(front).toThrow(/^POSITION_INDEX_OUT_OF_BOUNDS$/);
+    });
+    // isBackRow Tests
+    test('Should return true for back-row positions', () => {
+        expect(CourtPosition.isBackRow(CourtPosition.LEFT_BACK)).toEqual(true);
+        expect(CourtPosition.isBackRow(CourtPosition.MIDDLE_BACK)).toEqual(true);
+        expect(CourtPosition.isBackRow(CourtPosition.RIGHT_BACK)).toEqual(true);
+    });
+    test('Should return false for front-row positions', () => {
+        expect(CourtPosition.isBackRow(CourtPosition.LEFT_FRONT)).toEqual(false);
+        expect(CourtPosition.isBackRow(CourtPosition.MIDDLE_FRONT)).toEqual(false);
+        expect(CourtPosition.isBackRow(CourtPosition.RIGHT_FRONT)).toEqual(false);
+    });
+    test('Should throw Error providing an invalid position', () => {
+        function back() { CourtPosition.isBackRow(0); }
+        expect(back).toThrow(/^POSITION_INDEX_OUT_OF_BOUNDS: 0$/);
+    });
+    // getRow Tests
+    test('Should get all front-row positions', () => {
+        expect(CourtPosition.getRow(CourtRow.FRONT))
+            .toEqual([CourtPosition.LEFT_FRONT, CourtPosition.MIDDLE_FRONT, CourtPosition.RIGHT_FRONT]);
+    });
+    test('Should get all back-row positions', () => {
+        expect(CourtPosition.getRow(CourtRow.BACK))
+            .toEqual([CourtPosition.LEFT_BACK, CourtPosition.MIDDLE_BACK, CourtPosition.RIGHT_BACK]);
+    });
+    test('Should throw Error providing an invalid row', () => {
+        // @ts-expect-error
+        function row() { CourtPosition.getRow(CourtRow.FAKE); }
+        expect(row).toThrow(/^INVALID_ROW: undefined$/);
+    });
+});

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

@@ -0,0 +1,21 @@
+import { CourtPosition } from './court-position';
+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 namespace CourtTarget {
+    function getTeamSide(): CourtTarget[];
+    function getOpponentSide(): CourtTarget[];
+    function getSidePosition(position: number): CourtPosition;
+}

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

@@ -0,0 +1,39 @@
+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 = {}));
+// eslint-disable-next-line @typescript-eslint/no-namespace
+(function (CourtTarget) {
+    function getTeamSide() {
+        return [CourtTarget.TEAM_RIGHT_BACK, CourtTarget.TEAM_RIGHT_FRONT, CourtTarget.TEAM_MIDDLE_FRONT,
+            CourtTarget.TEAM_LEFT_FRONT, CourtTarget.TEAM_LEFT_BACK, CourtTarget.TEAM_MIDDLE_BACK];
+    }
+    CourtTarget.getTeamSide = getTeamSide;
+    function getOpponentSide() {
+        return [CourtTarget.OPPONENT_RIGHT_BACK, CourtTarget.OPPONENT_RIGHT_FRONT, CourtTarget.OPPONENT_MIDDLE_FRONT,
+            CourtTarget.OPPONENT_LEFT_FRONT, CourtTarget.OPPONENT_LEFT_BACK, CourtTarget.OPPONENT_MIDDLE_BACK];
+    }
+    CourtTarget.getOpponentSide = getOpponentSide;
+    function getSidePosition(position) {
+        if (position < 1 || position > 12)
+            throw new Error('POSITION_INDEX_OUT_OF_BOUNDS');
+        if (position > 6)
+            return position - 6;
+        else
+            return position;
+    }
+    CourtTarget.getSidePosition = getSidePosition;
+})(CourtTarget || (CourtTarget = {}));

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

@@ -0,0 +1 @@
+export {};

package/dist/esm/src/service/match/court-target.test.js

@@ -0,0 +1,35 @@
+import { describe, expect, test } from '@jest/globals';
+import { CourtTarget } from './court-target';
+describe('CourtTarget Test Module', () => {
+    // getSidePosition Tests
+    test('Should get correct court position', () => {
+        for (let i = 1; i < 7; i++) {
+            expect(CourtTarget.getSidePosition(i)).toBe(i);
+            expect(CourtTarget.getSidePosition(i + 6)).toBe(i);
+        }
+    });
+    test('Should throw Error when position is out of bounds', () => {
+        function position() { CourtTarget.getSidePosition(0); }
+        expect(position).toThrow(/^POSITION_INDEX_OUT_OF_BOUNDS$/);
+    });
+    // getTeamSide Tests
+    test('Should return team positions', () => {
+        const positions = CourtTarget.getTeamSide();
+        expect(positions[0]).toBe(CourtTarget.TEAM_RIGHT_BACK);
+        expect(positions[1]).toBe(CourtTarget.TEAM_RIGHT_FRONT);
+        expect(positions[2]).toBe(CourtTarget.TEAM_MIDDLE_FRONT);
+        expect(positions[3]).toBe(CourtTarget.TEAM_LEFT_FRONT);
+        expect(positions[4]).toBe(CourtTarget.TEAM_LEFT_BACK);
+        expect(positions[5]).toBe(CourtTarget.TEAM_MIDDLE_BACK);
+    });
+    // getOpponentSide Tests
+    test('Should return opponent team positions', () => {
+        const positions = CourtTarget.getOpponentSide();
+        expect(positions[0]).toBe(CourtTarget.OPPONENT_RIGHT_BACK);
+        expect(positions[1]).toBe(CourtTarget.OPPONENT_RIGHT_FRONT);
+        expect(positions[2]).toBe(CourtTarget.OPPONENT_MIDDLE_FRONT);
+        expect(positions[3]).toBe(CourtTarget.OPPONENT_LEFT_FRONT);
+        expect(positions[4]).toBe(CourtTarget.OPPONENT_LEFT_BACK);
+        expect(positions[5]).toBe(CourtTarget.OPPONENT_MIDDLE_BACK);
+    });
+});

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

@@ -0,0 +1,7 @@
+import { Match } from './match';
+import { EventStat, MatchSet, MatchSetOpts, MatchSetState, SetStatistics } from './match-set';
+import { PlayerPosition, Rally, RallyState } from './rally';
+import { CourtPosition, CourtRow } from './court-position';
+import { CourtTarget } from './court-target';
+import { MatchTeam } from './match-team';
+export { CourtPosition, CourtRow, CourtTarget, EventStat, Match, MatchSet, MatchSetOpts, MatchSetState, MatchTeam, PlayerPosition, Rally, RallyState, SetStatistics, };

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

@@ -0,0 +1,7 @@
+import { Match } from './match';
+import { MatchSet, MatchSetState, } from './match-set';
+import { Rally, RallyState, } from './rally';
+import { CourtPosition, CourtRow, } from './court-position';
+import { CourtTarget, } from './court-target';
+import { MatchTeam, } from './match-team';
+export { CourtPosition, CourtRow, CourtTarget, Match, MatchSet, MatchSetState, MatchTeam, Rally, RallyState, };

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

@@ -0,0 +1,71 @@
+import { Rally } from './rally';
+import { MatchTeam } from './match-team';
+import { Player } from '../player';
+export declare enum MatchSetState {
+    NEW = 0,
+    IN_PLAY = 1,
+    FINISHED = 2
+}
+export declare namespace MatchSetState {
+    function nextState(state: number): MatchSetState;
+}
+export interface MatchSetOpts {
+    readonly id: string;
+    readonly order: number;
+    readonly isTieBreak: boolean;
+    readonly homeLibero: Player | undefined;
+    readonly awayLibero: Player | undefined;
+    readonly homeScore: number;
+    readonly awayScore: number;
+    readonly stats: SetStatistics[];
+    readonly rallies: Rally[];
+}
+export interface EventStat {
+    success: number;
+    error: number;
+}
+export interface SetStatistics {
+    player: Player;
+    ace: number;
+    attempts: number;
+    contacts: number;
+    ralliesPlayed: number;
+    serve: EventStat;
+    reception: EventStat;
+    set: EventStat;
+    attack: EventStat;
+    block: EventStat;
+    kills: number;
+    killBlocks: number;
+    assists: number;
+}
+export declare class MatchSet {
+    readonly id: string;
+    readonly order: number;
+    readonly isTieBreak: boolean;
+    readonly homeLibero: Player | undefined;
+    readonly awayLibero: Player | undefined;
+    private readonly scoreThreshold;
+    private homeScore;
+    private awayScore;
+    readonly stats: SetStatistics[];
+    readonly rallies: Rally[];
+    constructor({ id, order, isTieBreak, homeLibero, awayLibero, stats, rallies, homeScore, awayScore }: MatchSetOpts);
+    getHomeScore(): number;
+    getAwayScore(): number;
+    private _state;
+    get state(): MatchSetState;
+    increaseScore(team: MatchTeam): void;
+    addRally(rally: Rally): void;
+    /**
+     * Has a team reached at least 25 points and is the score difference between both teams at least 2?
+     * @returns boolean
+     */
+    isOver(): boolean;
+    nextState(): void;
+    /**
+     * Get the team that won the Set. Return undefined if set is not over.
+     * @returns CourtTeam
+     */
+    getWinner(): MatchTeam;
+}

package/dist/esm/src/service/match/match-set.js

@@ -0,0 +1,85 @@
+import { validateUUID } from '../utils';
+import { MatchTeam } from './match-team';
+export var MatchSetState;
+(function (MatchSetState) {
+    MatchSetState[MatchSetState["NEW"] = 0] = "NEW";
+    MatchSetState[MatchSetState["IN_PLAY"] = 1] = "IN_PLAY";
+    MatchSetState[MatchSetState["FINISHED"] = 2] = "FINISHED";
+})(MatchSetState || (MatchSetState = {}));
+// eslint-disable-next-line @typescript-eslint/no-namespace
+(function (MatchSetState) {
+    function nextState(state) {
+        if (state < 0 || state > 2)
+            throw new Error('STATE_INDEX_OUT_OF_BOUNDS');
+        if (state === 2)
+            throw new Error(`CANT_GET_STATE_AFTER: ${MatchSetState[state]}`);
+        return state + 1;
+    }
+    MatchSetState.nextState = nextState;
+})(MatchSetState || (MatchSetState = {}));
+var ScoreThreshold;
+(function (ScoreThreshold) {
+    ScoreThreshold[ScoreThreshold["SET"] = 25] = "SET";
+    ScoreThreshold[ScoreThreshold["TIE_BREAK"] = 15] = "TIE_BREAK";
+})(ScoreThreshold || (ScoreThreshold = {}));
+export class MatchSet {
+    constructor({ id, order, isTieBreak, homeLibero, awayLibero, stats, rallies, homeScore, awayScore }) {
+        validateUUID(id);
+        this.id = id;
+        this.order = order;
+        this.homeScore = homeScore;
+        this.awayScore = awayScore;
+        this.homeLibero = homeLibero;
+        this.awayLibero = awayLibero;
+        this.stats = stats;
+        this.rallies = rallies;
+        this.isTieBreak = isTieBreak;
+        this.scoreThreshold = isTieBreak ? ScoreThreshold.TIE_BREAK : ScoreThreshold.SET;
+        this._state = MatchSetState.NEW;
+    }
+    getHomeScore() {
+        return this.homeScore;
+    }
+    getAwayScore() {
+        return this.awayScore;
+    }
+    get state() {
+        return this._state;
+    }
+    increaseScore(team) {
+        if (this._state !== MatchSetState.IN_PLAY || this.isOver())
+            throw new Error('CANNOT_INCREASE_SCORE_OF_SET');
+        if (team === MatchTeam.HOME)
+            this.homeScore++;
+        else if (team === MatchTeam.AWAY)
+            this.awayScore++;
+        else
+            throw new Error('UNKNOWN_TEAM');
+    }
+    addRally(rally) {
+        this.rallies.push(rally);
+    }
+    /**
+     * Has a team reached at least 25 points and is the score difference between both teams at least 2?
+     * @returns boolean
+     */
+    isOver() {
+        return Math.abs(this.homeScore - this.awayScore) > 1 &&
+            (this.homeScore >= this.scoreThreshold || this.awayScore >= this.scoreThreshold);
+    }
+    nextState() {
+        if (this._state === 1 && !this.isOver()) {
+            throw new Error('CANNOT_ADVANCE_SET_STATE');
+        }
+        this._state = MatchSetState.nextState(this._state);
+    }
+    /**
+     * Get the team that won the Set. Return undefined if set is not over.
+     * @returns CourtTeam
+     */
+    getWinner() {
+        if (!this.isOver())
+            throw new Error('UNFINISHED_SET');
+        return this.homeScore > this.awayScore ? MatchTeam.HOME : MatchTeam.AWAY;
+    }
+}

package/dist/esm/src/service/match/match-set.test.d.ts

@@ -0,0 +1 @@
+export {};