volleyballsimtypes 0.0.8 → 0.0.9

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

@@ -0,0 +1,150 @@
+import { describe, expect, test } from '@jest/globals';
+import { MatchSet, MatchSetState } from './match-set';
+import { MatchTeam } from './match-team';
+import { newRally } from './__stubs__';
+import { libero } from '../player/__stubs__';
+describe('MatchSet Test Module', () => {
+    let set;
+    let tieBreakSet;
+    beforeEach(() => {
+        set = new MatchSet({
+            id: '4a8d1149-0157-461c-afb4-8a2d9776da5a',
+            rallies: [],
+            stats: [],
+            awayScore: 0,
+            homeScore: 0,
+            order: 0,
+            isTieBreak: false,
+            homeLibero: libero,
+            awayLibero: libero
+        });
+        tieBreakSet = new MatchSet({
+            id: '5fed79c1-1146-45fb-acdd-acd4eb99bda3',
+            rallies: [],
+            stats: [],
+            awayScore: 0,
+            homeScore: 0,
+            order: 0,
+            isTieBreak: true,
+            homeLibero: libero,
+            awayLibero: libero
+        });
+    });
+    test('Should instantiate object properly', () => {
+        expect(set.id).toBe('4a8d1149-0157-461c-afb4-8a2d9776da5a');
+        expect(set.rallies.length).toBe(0);
+        expect(set.state).toBe(0);
+        expect(set.getHomeScore()).toBe(0);
+        expect(set.getAwayScore()).toBe(0);
+    });
+    // increaseScore Tests
+    test('Should increase score of home team', () => {
+        set.nextState();
+        expect(set.getHomeScore).toBe(0);
+        set.increaseScore(MatchTeam.HOME);
+        expect(set.getHomeScore).toBe(1);
+    });
+    test('Should increase score of away team', () => {
+        set.nextState();
+        expect(set.getAwayScore).toBe(0);
+        set.increaseScore(MatchTeam.AWAY);
+        expect(set.getAwayScore).toBe(1);
+    });
+    test('Should throw Error when trying to increase score of finished set', () => {
+        set.nextState();
+        for (let i = 0; i < 25; i++)
+            set.increaseScore(MatchTeam.HOME);
+        function fin1() { set.increaseScore(MatchTeam.HOME); }
+        function fin2() { tieBreakSet.increaseScore(MatchTeam.HOME); }
+        expect(fin1).toThrow(/^CANNOT_INCREASE_SCORE_OF_SET$/);
+        expect(fin2).toThrow(/^CANNOT_INCREASE_SCORE_OF_SET$/);
+    });
+    test('Should throw Error when providing invalid team', () => {
+        set.nextState();
+        // @ts-expect-error
+        function fin() { set.increaseScore(MatchTeam.OTHER); }
+        expect(fin).toThrow(/^UNKNOWN_TEAM$/);
+    });
+    // addRally Tests
+    test('Should rally to rally array', () => {
+        expect(set.rallies.length).toBe(0);
+        set.addRally(newRally);
+        expect(set.rallies.length).toBe(1);
+    });
+    // isOver Tests
+    test('Should return true for team reaching point threshold', () => {
+        set.nextState();
+        expect(set.isOver()).toBe(false);
+        for (let i = 0; i < 25; i++)
+            set.increaseScore(MatchTeam.HOME);
+        expect(set.isOver()).toBe(true);
+    });
+    test('Should return true for both teams reaching point threshold and point difference greater than 1', () => {
+        set.nextState();
+        for (let i = 0; i < 25; i++) {
+            set.increaseScore(MatchTeam.HOME);
+            set.increaseScore(MatchTeam.AWAY);
+        }
+        expect(set.isOver()).toBe(false);
+        set.increaseScore(MatchTeam.HOME);
+        expect(set.isOver()).toBe(false);
+        set.increaseScore(MatchTeam.HOME);
+        expect(set.isOver()).toBe(true);
+    });
+    // nextState Tests
+    test('Should advance to in play', () => {
+        expect(set.state).toBe(0);
+        set.nextState();
+        expect(set.state).toBe(1);
+    });
+    test('Should throw Error if in play and set not over', () => {
+        set.nextState();
+        function fin() { set.nextState(); }
+        expect(fin).toThrow(/^CANNOT_ADVANCE_SET_STATE$/);
+    });
+    test('Should advance to FINISHED if set is over', () => {
+        set.nextState();
+        for (let i = 0; i < 25; i++)
+            set.increaseScore(MatchTeam.HOME);
+        set.nextState();
+        expect(set.state).toBe(2);
+    });
+    test('Should throw Error when trying to transition from FINISHED state', () => {
+        set.nextState();
+        for (let i = 0; i < 25; i++)
+            set.increaseScore(MatchTeam.HOME);
+        set.nextState();
+        function fin() { set.nextState(); }
+        expect(fin).toThrow(/^CANT_GET_STATE_AFTER: FINISHED$/);
+    });
+    // getWinner Tests
+    test('Should throw Error when getting winner of unfinished set', () => {
+        function fin() { set.getWinner(); }
+        expect(fin).toThrow(/^UNFINISHED_SET$/);
+    });
+    test('Should get correct set winner', () => {
+        set.nextState();
+        for (let i = 0; i < 25; i++)
+            set.increaseScore(MatchTeam.HOME);
+        expect(set.getWinner()).toBe(MatchTeam.HOME);
+        tieBreakSet.nextState();
+        for (let i = 0; i < 15; i++)
+            tieBreakSet.increaseScore(MatchTeam.AWAY);
+        expect(tieBreakSet.getWinner()).toBe(MatchTeam.AWAY);
+    });
+    // MatchSetState Tests
+    test('Should get next state', () => {
+        expect(MatchSetState.nextState(0)).toBe(1);
+        expect(MatchSetState.nextState(1)).toBe(2);
+    });
+    test('Should throw Error for state outside range', () => {
+        function fn1() { MatchSetState.nextState(-1); }
+        function fn2() { MatchSetState.nextState(3); }
+        expect(fn1).toThrow(/^STATE_INDEX_OUT_OF_BOUNDS$/);
+        expect(fn2).toThrow(/^STATE_INDEX_OUT_OF_BOUNDS$/);
+    });
+    test('Should throw Error for last state', () => {
+        function fn() { MatchSetState.nextState(2); }
+        expect(fn).toThrow(/^CANT_GET_STATE_AFTER: FINISHED$/);
+    });
+});

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

@@ -0,0 +1,7 @@
+export declare enum MatchTeam {
+    HOME = "homeTeam",
+    AWAY = "awayTeam"
+}
+export declare namespace MatchTeam {
+    function otherTeam(team: MatchTeam): MatchTeam;
+}

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

@@ -0,0 +1,17 @@
+export var MatchTeam;
+(function (MatchTeam) {
+    MatchTeam["HOME"] = "homeTeam";
+    MatchTeam["AWAY"] = "awayTeam";
+})(MatchTeam || (MatchTeam = {}));
+// eslint-disable-next-line @typescript-eslint/no-namespace
+(function (MatchTeam) {
+    function otherTeam(team) {
+        if (team === MatchTeam.HOME)
+            return MatchTeam.AWAY;
+        else if (team === MatchTeam.AWAY)
+            return MatchTeam.HOME;
+        else
+            throw new Error('UNKNOWN_MATCH_TEAM');
+    }
+    MatchTeam.otherTeam = otherTeam;
+})(MatchTeam || (MatchTeam = {}));

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

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

package/dist/esm/src/service/match/match-team.test.js

@@ -0,0 +1,14 @@
+import { describe, expect, test } from '@jest/globals';
+import { MatchTeam } from './match-team';
+describe('MatchTeam Test Module', () => {
+    // otherTeam Tests
+    test('Should return correct team string', () => {
+        expect(MatchTeam.otherTeam(MatchTeam.AWAY)).toBe(MatchTeam.HOME);
+        expect(MatchTeam.otherTeam(MatchTeam.HOME)).toBe(MatchTeam.AWAY);
+    });
+    test('Should throw Error when providing invalid MatchTeam', () => {
+        // @ts-expect-error
+        function team() { MatchTeam.otherTeam(MatchTeam.OTHER); }
+        expect(team).toThrow(/^UNKNOWN_MATCH_TEAM$/);
+    });
+});

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

@@ -0,0 +1,24 @@
+import { MatchSet } from './match-set';
+import { Team } from '../team';
+import { MatchTeam } from './match-team';
+interface MatchOpts {
+    readonly id: string;
+    readonly homeTeam: Team;
+    readonly awayTeam: Team;
+    readonly scheduledDate: Date;
+    readonly sets: MatchSet[];
+}
+export declare class Match {
+    static readonly BEST_OF = 5;
+    readonly id: string;
+    readonly homeTeam: Team;
+    readonly awayTeam: Team;
+    readonly sets: MatchSet[];
+    readonly scheduledDate: Date;
+    constructor({ id, homeTeam, awayTeam, scheduledDate, sets }: MatchOpts);
+    addSet(set: MatchSet): void;
+    getTeamSets(team: MatchTeam): number;
+    isOver(): boolean;
+    getWinner(): Team;
+}
+export {};

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

@@ -0,0 +1,38 @@
+import { validateUUID } from '../utils';
+import { MatchTeam } from './match-team';
+export class Match {
+    constructor({ id, homeTeam, awayTeam, scheduledDate, sets }) {
+        validateUUID(id);
+        this.id = id;
+        this.homeTeam = homeTeam;
+        this.awayTeam = awayTeam;
+        this.scheduledDate = scheduledDate;
+        this.sets = sets;
+    }
+    addSet(set) {
+        if (this.sets.length >= Match.BEST_OF)
+            throw new Error('SET_AMOUNT_EXCEEDED');
+        this.sets.push(set);
+    }
+    getTeamSets(team) {
+        return this.sets.reduce((sets, set) => sets + (!set.isOver() ? 0 : set.getWinner() === team ? 1 : 0), 0);
+    }
+    isOver() {
+        const gamesRequired = Math.ceil(Match.BEST_OF / 2);
+        const lastSet = this.sets.at(-1);
+        if (lastSet == null || !lastSet.isOver() || this.sets.length < gamesRequired)
+            return false;
+        const homeSets = this.getTeamSets(MatchTeam.HOME);
+        const awaySets = this.getTeamSets(MatchTeam.AWAY);
+        // Check if any of the teams has enough sets to win.
+        return !(homeSets < gamesRequired && awaySets < gamesRequired);
+    }
+    getWinner() {
+        if (!this.isOver())
+            throw new Error('UNFINISHED_MATCH');
+        const homeSets = this.getTeamSets(MatchTeam.HOME);
+        const awaySets = this.getTeamSets(MatchTeam.AWAY);
+        return homeSets > awaySets ? this.homeTeam : this.awayTeam;
+    }
+}
+Match.BEST_OF = 5;

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

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

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

@@ -0,0 +1,70 @@
+import { describe, expect, test } from '@jest/globals';
+import { Match } from './match';
+import { noLiberoTeam, team } from '../team/__stubs__';
+import { finishedSet, inProgressSet, newSet } from './__stubs__';
+import { MatchTeam } from './match-team';
+describe('Match Test Module', () => {
+    let match;
+    beforeEach(() => {
+        match = new Match({
+            id: '1f7f63bc-6bfd-4f3d-bc46-b8c6d210664e',
+            sets: [],
+            homeTeam: team,
+            awayTeam: noLiberoTeam,
+            scheduledDate: new Date('2020-01-01')
+        });
+    });
+    test('Should instantiate object properly', () => {
+        expect(match.id).toBe('1f7f63bc-6bfd-4f3d-bc46-b8c6d210664e');
+        expect(match.homeTeam.id).toBe(team.id);
+        expect(match.awayTeam.id).toBe(noLiberoTeam.id);
+        expect(match.sets.length).toBe(0);
+        expect(match.scheduledDate.toUTCString()).toBe('Wed, 01 Jan 2020 00:00:00 GMT');
+    });
+    // addSet Tests
+    test('Should add a set to sets array', () => {
+        expect(match.sets.length).toBe(0);
+        match.addSet(newSet);
+        expect(match.sets.length).toBe(1);
+    });
+    test('Should throw an Error when trying to add a set after limit was reached', () => {
+        match.addSet(newSet);
+        match.addSet(newSet);
+        match.addSet(newSet);
+        function add() { match.addSet(newSet); }
+        expect(add).toThrow(/^SET_AMOUNT_EXCEEDED$/);
+    });
+    // getTeamSets Tests
+    test('Should return proper amount of sets per team', () => {
+        expect(match.getTeamSets(MatchTeam.HOME)).toBe(0);
+        match.addSet(finishedSet);
+        expect(match.getTeamSets(MatchTeam.HOME)).toBe(1);
+        expect(match.getTeamSets(MatchTeam.AWAY)).toBe(0);
+        match.addSet(inProgressSet);
+        expect(match.getTeamSets(MatchTeam.AWAY)).toBe(0);
+    });
+    // isOver Tests
+    test('Should return false when match is not over', () => {
+        expect(match.isOver()).toBe(false);
+        match.addSet(finishedSet);
+        expect(match.isOver()).toBe(false);
+    });
+    test('Should return true when match is over', () => {
+        match.addSet(finishedSet);
+        match.addSet(finishedSet);
+        match.addSet(finishedSet);
+        expect(match.isOver()).toBe(true);
+    });
+    // getWinner Tests
+    test('Should throw an Error when getting winner of unfinished match', () => {
+        function win() { match.getWinner(); }
+        expect(win).toThrow(/^UNFINISHED_MATCH$/);
+    });
+    test('Should return winning team', () => {
+        match.addSet(finishedSet);
+        match.addSet(finishedSet);
+        match.addSet(finishedSet);
+        const winner = match.getWinner();
+        expect(winner.id).toBe('426b5b9b-5be7-4963-92eb-71b7a3b29ffd');
+    });
+});

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

@@ -0,0 +1,41 @@
+import { Team } from '../team';
+import { CourtPosition } from './court-position';
+import { RallyEvent } from '../event/rally-event';
+import { Score } from '../event/score';
+interface RallyOpts {
+    readonly id: string;
+    readonly order: number;
+    readonly servingTeam: Team;
+    readonly events: RallyEvent[];
+    readonly homePlayerPosition: PlayerPosition[];
+    readonly awayPlayerPosition: PlayerPosition[];
+}
+export interface PlayerPosition {
+    position: CourtPosition;
+    playerId: string;
+}
+export declare enum RallyState {
+    NEW = 0,
+    MANAGEMENT = 1,
+    IN_PLAY = 2,
+    FINISHED = 3
+}
+export declare namespace RallyState {
+    function nextState(state: number): RallyState;
+}
+export declare class Rally {
+    readonly id: string;
+    readonly servingTeam: Team;
+    readonly events: RallyEvent[];
+    readonly homePlayerPosition: PlayerPosition[];
+    readonly awayPlayerPosition: PlayerPosition[];
+    readonly order: number;
+    constructor({ id, order, servingTeam, homePlayerPosition, awayPlayerPosition, events }: RallyOpts);
+    private _state;
+    get state(): RallyState;
+    get score(): Score | undefined;
+    isOver(): boolean;
+    addEvent(event: RallyEvent): void;
+    nextState(): void;
+}
+export {};

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

@@ -0,0 +1,47 @@
+import { validateUUID } from '../utils';
+import { EventType } from '../event/rally-event';
+export var RallyState;
+(function (RallyState) {
+    RallyState[RallyState["NEW"] = 0] = "NEW";
+    RallyState[RallyState["MANAGEMENT"] = 1] = "MANAGEMENT";
+    RallyState[RallyState["IN_PLAY"] = 2] = "IN_PLAY";
+    RallyState[RallyState["FINISHED"] = 3] = "FINISHED";
+})(RallyState || (RallyState = {}));
+// eslint-disable-next-line @typescript-eslint/no-namespace
+(function (RallyState) {
+    function nextState(state) {
+        if (state < 0 || state > 3)
+            throw new Error('STATE_INDEX_OUT_OF_BOUNDS');
+        if (state === 3)
+            throw new Error(`CANT_GET_STATE_AFTER: ${RallyState[state]}`);
+        return state + 1;
+    }
+    RallyState.nextState = nextState;
+})(RallyState || (RallyState = {}));
+export class Rally {
+    constructor({ id, order, servingTeam, homePlayerPosition, awayPlayerPosition, events }) {
+        validateUUID(id);
+        this.id = id;
+        this.order = order;
+        this.servingTeam = servingTeam;
+        this.homePlayerPosition = homePlayerPosition;
+        this.awayPlayerPosition = awayPlayerPosition;
+        this.events = events;
+        this._state = RallyState.NEW;
+    }
+    get state() {
+        return this._state;
+    }
+    get score() {
+        return this.events.find(e => e.eventType === EventType.SCORE);
+    }
+    isOver() {
+        return this._state === RallyState.FINISHED;
+    }
+    addEvent(event) {
+        this.events.push(event);
+    }
+    nextState() {
+        this._state = RallyState.nextState(this._state);
+    }
+}

package/dist/esm/src/service/match/rally.test.d.ts

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

package/dist/esm/src/service/match/rally.test.js

@@ -0,0 +1,86 @@
+import { describe, expect, test } from '@jest/globals';
+import { Rally, RallyState } from './rally';
+import { score, serve } from '../event/__stubs__';
+import { EventType } from '../event/rally-event';
+import { team } from '../team/__stubs__';
+describe('Rally Test Module', () => {
+    let rally;
+    beforeEach(() => {
+        rally = new Rally({
+            events: [],
+            order: 0,
+            servingTeam: team,
+            id: '0ac3ba3a-d710-42dc-a1e7-7066b8df5fd9',
+            homePlayerPosition: [],
+            awayPlayerPosition: []
+        });
+    });
+    test('Should instantiate the object properly', () => {
+        expect(rally.id).toBe('0ac3ba3a-d710-42dc-a1e7-7066b8df5fd9');
+        expect(rally.servingTeam.id).toBe('426b5b9b-5be7-4963-92eb-71b7a3b29ffd');
+        expect(rally.events.length).toBe(0);
+        expect(rally.state).toBe(0);
+    });
+    // nextState Tests
+    test('Should cycle through states correctly', () => {
+        expect(rally.state).toBe(0);
+        rally.nextState();
+        expect(rally.state).toBe(1);
+        rally.nextState();
+        expect(rally.state).toBe(2);
+        rally.nextState();
+        expect(rally.state).toBe(3);
+    });
+    test('Should throw Error when trying to get next state after FINISHED', () => {
+        function state() {
+            rally.nextState();
+            rally.nextState();
+            rally.nextState();
+            rally.nextState();
+        }
+        expect(state).toThrow(/^CANT_GET_STATE_AFTER: FINISHED$/);
+    });
+    // addEvent Tests
+    test('Should add event to event array', () => {
+        expect(rally.events.length).toBe(0);
+        rally.addEvent(serve);
+        expect(rally.events.at(-1)?.eventType).toBe(EventType.SERVE);
+    });
+    // isOver Tests
+    test('Should return false if rally state is not FINISHED', () => {
+        expect(rally.state).toBe(0);
+        expect(rally.isOver()).toBe(false);
+    });
+    test('Should return true if rally state is FINISHED', () => {
+        rally.nextState();
+        rally.nextState();
+        rally.nextState();
+        expect(rally.state).toBe(3);
+        expect(rally.isOver()).toBe(true);
+    });
+    // getScore Tests
+    test('Should return undefined if events array does not contain a Score', () => {
+        rally.addEvent(serve);
+        expect(rally.score).toBeUndefined();
+    });
+    test('Should return Score if events array contains a Score', () => {
+        rally.addEvent(score);
+        expect(rally.score).not.toBeUndefined();
+        expect(rally.score?.eventType).toBe(EventType.SCORE);
+    });
+    // RallyState Tests
+    test('Should get next state', () => {
+        expect(RallyState.nextState(0)).toBe(1);
+        expect(RallyState.nextState(1)).toBe(2);
+    });
+    test('Should throw Error for state outside range', () => {
+        function fn1() { RallyState.nextState(-1); }
+        function fn2() { RallyState.nextState(4); }
+        expect(fn1).toThrow(/^STATE_INDEX_OUT_OF_BOUNDS$/);
+        expect(fn2).toThrow(/^STATE_INDEX_OUT_OF_BOUNDS$/);
+    });
+    test('Should throw Error for last state', () => {
+        function fn() { RallyState.nextState(3); }
+        expect(fn).toThrow(/^CANT_GET_STATE_AFTER: FINISHED$/);
+    });
+});

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

@@ -0,0 +1,28 @@
+import { Player } from '../player';
+import { PerformanceStats } from '../performance-stats';
+import { Role } from '../role';
+import { GeneralStat } from '../stats';
+import { Trait } from '../trait';
+export declare const performance: PerformanceStats;
+export declare const personal: {
+    name: {
+        first: string;
+        last: string;
+    };
+    country: import("../..").Country;
+};
+export declare const personalDec: {
+    name: {
+        first: string;
+        last: string;
+    };
+    country: import("../..").Country;
+};
+export declare const player: Player;
+export declare const players: Player[];
+export declare const libero: Player;
+export declare const performanceStats: PerformanceStats;
+export declare const roles: Role[];
+export declare const traits: Trait[];
+export declare const stats: GeneralStat[];
+export declare const rosters: Player[][];