volleyballsimtypes 0.0.100 → 0.0.102

package/dist/esm/src/service/event/reception.test.js

@@ -1,49 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import { Reception, ReceptionFailureEnum, ReceptionTypeEnum } from './reception';
-import { player } from '../player/__stubs__';
-import { CourtTargetEnum } from '../match';
-import { EventTypeEnum } from './rally-event';
-describe('Reception Test Module', () => {
-    let reception;
-    let failed;
-    beforeEach(() => {
-        reception = new Reception({
-            score: 60,
-            id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
-            order: 0,
-            player: player,
-            target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
-            failure: ReceptionFailureEnum.NO_FAILURE,
-            type: ReceptionTypeEnum.DIG,
-            eventType: EventTypeEnum.RECEPTION,
-            modifier: 1,
-            activeTraits: []
-        });
-        failed = new Reception({
-            score: 60,
-            id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
-            order: 0,
-            player: player,
-            target: CourtTargetEnum.NO_TARGET,
-            failure: ReceptionFailureEnum.OUT_OF_BOUNDS,
-            type: ReceptionTypeEnum.OTHER_BODY_PART,
-            eventType: EventTypeEnum.RECEPTION,
-            modifier: 1,
-            activeTraits: []
-        });
-    });
-    test('Should instantiate object properly', () => {
-        expect(reception.target).toBe(CourtTargetEnum.OPPONENT_RIGHT_BACK);
-        expect(reception.type).toBe(ReceptionTypeEnum.DIG);
-        expect(reception.eventType).toBe(EventTypeEnum.RECEPTION);
-        expect(reception.player.id).toBe(player.id);
-        expect(reception.failure).toBe(ReceptionFailureEnum.NO_FAILURE);
-        expect(failed.failure).toBe(ReceptionFailureEnum.OUT_OF_BOUNDS);
-        expect(reception.modifier).toBe(1);
-    });
-    // getScore Tests
-    test('Should get the correct score for all Reception types', () => {
-        expect(Reception.getScore(reception.player.stats, reception.type, 1, [])).toBe(4);
-        expect(Reception.getScore(failed.player.stats, failed.type, 1, [])).toBe(3);
-    });
-});

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

@@ -1,13 +0,0 @@
-import { RallyEvent, RallyEventOpts } from './rally-event';
-import { Team } from '../team';
-import { Player } from '../player';
-interface ScoreOpts extends RallyEventOpts {
-    player: Player;
-    team: Team;
-}
-export declare class Score extends RallyEvent {
-    readonly team: Team;
-    constructor({ id, order, player, team, eventType }: ScoreOpts);
-    printEvent(): string;
-}
-export {};

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

@@ -1,10 +0,0 @@
-import { RallyEvent } from './rally-event';
-export class Score extends RallyEvent {
-    constructor({ id, order, player, team, eventType }) {
-        super({ id, order, player, eventType });
-        this.team = team;
-    }
-    printEvent() {
-        return `event: SCORE, team: ${this.team.name} [${this.team.shortName}]`;
-    }
-}

package/dist/esm/src/service/event/score.test.d.ts

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

package/dist/esm/src/service/event/score.test.js

@@ -1,26 +0,0 @@
-import { beforeEach, describe, expect, test } from '@jest/globals';
-import { Score } from './score';
-import { player } from '../player/__stubs__';
-import { team } from '../team/__stubs__';
-import { EventTypeEnum } from './rally-event';
-describe('Score Test Module', () => {
-    let score;
-    beforeEach(() => {
-        score = new Score({
-            id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
-            order: 0,
-            eventType: EventTypeEnum.SCORE,
-            player: player,
-            team
-        });
-    });
-    test('Should instantiate object properly', () => {
-        expect(score.eventType).toBe(EventTypeEnum.SCORE);
-        expect(score.player.id).toBe('e92f4abb-66f4-4b6c-a602-258404d04484');
-        expect(score.team.id).toBe('426b5b9b-5be7-4963-92eb-71b7a3b29ffd');
-    });
-    // printEvent Test
-    test('Should print event properly', () => {
-        expect(score.printEvent()).toBe('event: SCORE, team: Yodo [YOD]');
-    });
-});

package/dist/esm/src/service/event/serve.test.d.ts

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

package/dist/esm/src/service/event/serve.test.js

@@ -1,49 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import { Serve, ServeFailureEnum, ServeTypeEnum } from './serve';
-import { player } from '../player/__stubs__';
-import { CourtTargetEnum } from '../match';
-import { EventTypeEnum } from './rally-event';
-describe('Serve Test Module', () => {
-    let serve;
-    let failed;
-    beforeEach(() => {
-        serve = new Serve({
-            score: 60,
-            id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
-            order: 0,
-            player: player,
-            target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
-            failure: ServeFailureEnum.NO_FAILURE,
-            type: ServeTypeEnum.JUMP_TOPSPIN,
-            eventType: EventTypeEnum.SERVE,
-            modifier: 1,
-            activeTraits: []
-        });
-        failed = new Serve({
-            score: 60,
-            id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
-            order: 0,
-            player: player,
-            target: CourtTargetEnum.NO_TARGET,
-            failure: ServeFailureEnum.NET,
-            type: ServeTypeEnum.UNDERHAND,
-            eventType: EventTypeEnum.SERVE,
-            modifier: 1,
-            activeTraits: []
-        });
-    });
-    test('Should instantiate object properly', () => {
-        expect(serve.target).toBe(CourtTargetEnum.OPPONENT_RIGHT_BACK);
-        expect(serve.type).toBe(ServeTypeEnum.JUMP_TOPSPIN);
-        expect(serve.eventType).toBe(EventTypeEnum.SERVE);
-        expect(serve.player.id).toBe(player.id);
-        expect(serve.failure).toBe(ServeFailureEnum.NO_FAILURE);
-        expect(failed.failure).toBe(ServeFailureEnum.NET);
-        expect(serve.modifier).toBe(1);
-    });
-    // getScore Tests
-    test('Should get the correct score for all Serve types', () => {
-        expect(Serve.getScore(serve.player.stats, serve.type, 1, [])).toBe(6);
-        expect(Serve.getScore(failed.player.stats, failed.type, 1, [])).toBe(3);
-    });
-});

package/dist/esm/src/service/event/set.test.d.ts

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

package/dist/esm/src/service/event/set.test.js

@@ -1,49 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import { Set, SetFailureEnum, SetTypeEnum } from './set';
-import { player } from '../player/__stubs__';
-import { CourtTargetEnum } from '../match';
-import { EventTypeEnum } from './rally-event';
-describe('Set Test Module', () => {
-    let set;
-    let failed;
-    beforeEach(() => {
-        set = new Set({
-            score: 60,
-            id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
-            order: 0,
-            player: player,
-            target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
-            failure: SetFailureEnum.NO_FAILURE,
-            type: SetTypeEnum.OVERHAND,
-            eventType: EventTypeEnum.SET,
-            modifier: 1,
-            activeTraits: []
-        });
-        failed = new Set({
-            score: 60,
-            id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
-            order: 0,
-            player: player,
-            target: CourtTargetEnum.NO_TARGET,
-            failure: SetFailureEnum.OUT_OF_BOUNDS,
-            type: SetTypeEnum.DUMP,
-            eventType: EventTypeEnum.SET,
-            modifier: 1,
-            activeTraits: []
-        });
-    });
-    test('Should instantiate object properly', () => {
-        expect(set.target).toBe(CourtTargetEnum.OPPONENT_RIGHT_BACK);
-        expect(set.type).toBe(SetTypeEnum.OVERHAND);
-        expect(set.eventType).toBe(EventTypeEnum.SET);
-        expect(set.player.id).toBe(player.id);
-        expect(set.failure).toBe(SetFailureEnum.NO_FAILURE);
-        expect(failed.failure).toBe(SetFailureEnum.OUT_OF_BOUNDS);
-        expect(set.modifier).toBe(1);
-    });
-    // getScore Tests
-    test('Should get the correct score for all Set types', () => {
-        expect(Set.getScore(set.player.stats, set.type, 1, [])).toBe(3);
-        expect(Set.getScore(failed.player.stats, failed.type, 1, [])).toBe(6);
-    });
-});

package/dist/esm/src/service/event/spike.test.d.ts

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

package/dist/esm/src/service/event/spike.test.js

@@ -1,64 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import { Spike, SpikeFailureEnum, SpikeTypeEnum } from './spike';
-import { player } from '../player/__stubs__';
-import { CourtTargetEnum } from '../match';
-import { EventTypeEnum } from './rally-event';
-import { v4 as uuidv4 } from 'uuid';
-describe('Spike Test Module', () => {
-    let spike;
-    let failed;
-    let backAttack;
-    beforeEach(() => {
-        spike = new Spike({
-            id: uuidv4(),
-            order: 1,
-            player: player,
-            target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
-            failure: SpikeFailureEnum.NO_FAILURE,
-            type: SpikeTypeEnum.CROSS_SHOT,
-            eventType: EventTypeEnum.SPIKE,
-            modifier: 1,
-            score: Spike.getScore(player, SpikeTypeEnum.CROSS_SHOT, 1, false, []),
-            activeTraits: []
-        });
-        failed = new Spike({
-            id: uuidv4(),
-            order: 1,
-            player: player,
-            target: CourtTargetEnum.NO_TARGET,
-            failure: SpikeFailureEnum.OUT_OF_BOUNDS,
-            type: SpikeTypeEnum.TIP,
-            eventType: EventTypeEnum.SPIKE,
-            modifier: 1,
-            score: Spike.getScore(player, SpikeTypeEnum.TIP, 1, false, []),
-            activeTraits: []
-        });
-        backAttack = new Spike({
-            id: uuidv4(),
-            order: 1,
-            player: player,
-            target: CourtTargetEnum.OPPONENT_RIGHT_BACK,
-            failure: SpikeFailureEnum.NO_FAILURE,
-            type: SpikeTypeEnum.CROSS_SHOT,
-            eventType: EventTypeEnum.SPIKE,
-            modifier: 1,
-            score: Spike.getScore(player, SpikeTypeEnum.CROSS_SHOT, 1, true, []),
-            activeTraits: []
-        });
-    });
-    test('Should instantiate object properly', () => {
-        expect(spike.target).toBe(CourtTargetEnum.OPPONENT_RIGHT_BACK);
-        expect(spike.type).toBe(SpikeTypeEnum.CROSS_SHOT);
-        expect(spike.eventType).toBe(EventTypeEnum.SPIKE);
-        expect(spike.player.id).toBe(player.id);
-        expect(spike.failure).toBe(SpikeFailureEnum.NO_FAILURE);
-        expect(failed.failure).toBe(SpikeFailureEnum.OUT_OF_BOUNDS);
-        expect(spike.modifier).toBe(1);
-    });
-    // getScore Tests
-    test('Should get the correct score for all Spike types', () => {
-        expect(spike.score).toBe(8);
-        expect(failed.score).toBe(7);
-        expect(backAttack.score).toBe(6.5);
-    });
-});

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

@@ -1,11 +0,0 @@
-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

@@ -1,116 +0,0 @@
-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
-    });
-    for (let i = 0; i < 25; i++) {
-        set.increaseScore(MatchTeam.HOME);
-    }
-    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
-    });
-    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,
-        rating: 1000,
-        roster: rosters[0],
-        coach: coaches[0]
-    }),
-    new Team({
-        id: 'f244d62d-f0ec-4005-8eb2-d955b0b8b191',
-        name: 'Fatz',
-        shortName: 'FAT',
-        country,
-        rating: 1000,
-        roster: rosters[1],
-        coach: coaches[1]
-    }),
-    new Team({
-        id: '749a5755-5c8b-4b07-aca9-1365a26c9a2e',
-        name: 'Tagtune',
-        shortName: 'TAG',
-        country,
-        rating: 1000,
-        roster: rosters[2],
-        coach: coaches[2]
-    }),
-    new Team({
-        id: 'd3dd532d-4898-44a3-853f-25f6fbdb3534',
-        name: 'Gigabox',
-        shortName: 'GIG',
-        country,
-        rating: 1000,
-        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'),
-    isSimulated: false
-});
-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'),
-    isSimulated: false
-});

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

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

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

@@ -1,67 +0,0 @@
-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.test.d.ts

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

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

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

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

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

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

@@ -1,100 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import { MatchSet } 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.getHomeScore()).toBe(0);
-        expect(set.getAwayScore()).toBe(0);
-    });
-    // increaseScore Tests
-    test('Should increase score of home team', () => {
-        expect(set.getHomeScore).toBe(0);
-        set.increaseScore(MatchTeam.HOME);
-        expect(set.getHomeScore).toBe(1);
-    });
-    test('Should increase score of away team', () => {
-        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', () => {
-        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', () => {
-        // @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', () => {
-        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', () => {
-        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);
-    });
-    // 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', () => {
-        for (let i = 0; i < 25; i++)
-            set.increaseScore(MatchTeam.HOME);
-        expect(set.getWinner()).toBe(MatchTeam.HOME);
-        for (let i = 0; i < 15; i++)
-            tieBreakSet.increaseScore(MatchTeam.AWAY);
-        expect(tieBreakSet.getWinner()).toBe(MatchTeam.AWAY);
-    });
-});

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

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

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

@@ -1,14 +0,0 @@
-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.test.d.ts

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