volleyballsimtypes 0.0.99 → 0.0.101

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

@@ -1,10 +1,10 @@
-export * from './score';
-export * from './set';
-export * from './block';
-export * from './serve';
-export * from './in-play-event';
-export * from './rally-event';
-export * from './reception';
-export * from './spike';
-export * from './substitution';
-export * from './libero-replacement';
+export * from './score';
+export * from './set';
+export * from './block';
+export * from './serve';
+export * from './in-play-event';
+export * from './rally-event';
+export * from './reception';
+export * from './spike';
+export * from './substitution';
+export * from './libero-replacement';

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

@@ -1,10 +1,10 @@
-export * from './score';
-export * from './set';
-export * from './block';
-export * from './serve';
-export * from './in-play-event';
-export * from './rally-event';
-export * from './reception';
-export * from './spike';
-export * from './substitution';
-export * from './libero-replacement';
+export * from './score';
+export * from './set';
+export * from './block';
+export * from './serve';
+export * from './in-play-event';
+export * from './rally-event';
+export * from './reception';
+export * from './spike';
+export * from './substitution';
+export * from './libero-replacement';

package/dist/esm/src/service/event/libero-replacement.d.ts

@@ -1,17 +1,17 @@
-import { RallyEvent, RallyEventOpts } from './rally-event';
-import { Player } from '../player';
-interface LiberoReplacementOpts extends RallyEventOpts {
-    readonly player: Player;
-    readonly libero: Player;
-    readonly type: LiberoReplacementTypeEnum;
-}
-export declare enum LiberoReplacementTypeEnum {
-    LIBERO_IN = 0,
-    LIBERO_OUT = 1
-}
-export declare class LiberoReplacement extends RallyEvent {
-    readonly type: LiberoReplacementTypeEnum;
-    readonly libero: Player;
-    constructor({ id, order, player, type, libero, eventType }: LiberoReplacementOpts);
-}
-export {};
+import { RallyEvent, RallyEventOpts } from './rally-event';
+import { Player } from '../player';
+interface LiberoReplacementOpts extends RallyEventOpts {
+    readonly player: Player;
+    readonly libero: Player;
+    readonly type: LiberoReplacementTypeEnum;
+}
+export declare enum LiberoReplacementTypeEnum {
+    LIBERO_IN = 0,
+    LIBERO_OUT = 1
+}
+export declare class LiberoReplacement extends RallyEvent {
+    readonly type: LiberoReplacementTypeEnum;
+    readonly libero: Player;
+    constructor({ id, order, player, type, libero, eventType }: LiberoReplacementOpts);
+}
+export {};

package/dist/esm/src/service/event/libero-replacement.js

@@ -1,13 +1,13 @@
-import { RallyEvent } from './rally-event';
-export var LiberoReplacementTypeEnum;
-(function (LiberoReplacementTypeEnum) {
-    LiberoReplacementTypeEnum[LiberoReplacementTypeEnum["LIBERO_IN"] = 0] = "LIBERO_IN";
-    LiberoReplacementTypeEnum[LiberoReplacementTypeEnum["LIBERO_OUT"] = 1] = "LIBERO_OUT";
-})(LiberoReplacementTypeEnum || (LiberoReplacementTypeEnum = {}));
-export class LiberoReplacement extends RallyEvent {
-    constructor({ id, order, player, type, libero, eventType }) {
-        super({ id, order, player, eventType });
-        this.type = type;
-        this.libero = libero;
-    }
-}
+import { RallyEvent } from './rally-event';
+export var LiberoReplacementTypeEnum;
+(function (LiberoReplacementTypeEnum) {
+    LiberoReplacementTypeEnum[LiberoReplacementTypeEnum["LIBERO_IN"] = 0] = "LIBERO_IN";
+    LiberoReplacementTypeEnum[LiberoReplacementTypeEnum["LIBERO_OUT"] = 1] = "LIBERO_OUT";
+})(LiberoReplacementTypeEnum || (LiberoReplacementTypeEnum = {}));
+export class LiberoReplacement extends RallyEvent {
+    constructor({ id, order, player, type, libero, eventType }) {
+        super({ id, order, player, eventType });
+        this.type = type;
+        this.libero = libero;
+    }
+}

package/dist/esm/src/service/event/libero-replacement.test.d.ts

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

package/dist/esm/src/service/event/libero-replacement.test.js

@@ -1,34 +1,34 @@
-import { beforeEach, describe, expect, test } from '@jest/globals';
-import { EventTypeEnum } from './rally-event';
-import { players } from '../player/__stubs__';
-import { LiberoReplacement, LiberoReplacementTypeEnum } from './libero-replacement';
-import { v4 as uuidv4 } from 'uuid';
-describe('LiberoReplacement Test Module', () => {
-    let _in;
-    let _out;
-    beforeEach(() => {
-        _in = new LiberoReplacement({
-            id: uuidv4(),
-            order: 1,
-            player: players[0],
-            libero: players[1],
-            type: LiberoReplacementTypeEnum.LIBERO_IN,
-            eventType: EventTypeEnum.LIBERO_REPLACEMENT
-        });
-        _out = new LiberoReplacement({
-            id: uuidv4(),
-            order: 1,
-            player: players[0],
-            libero: players[1],
-            type: LiberoReplacementTypeEnum.LIBERO_OUT,
-            eventType: EventTypeEnum.LIBERO_REPLACEMENT
-        });
-    });
-    test('Should instantiate object properly', () => {
-        expect(_in.libero.id).toBe('e92f4abb-66f4-4b6c-a602-258404d04484');
-        expect(_in.player.id).toBe('622c36dc-f2d2-44b3-a744-667ea53218b7');
-        expect(_in.type).toBe(LiberoReplacementTypeEnum.LIBERO_IN);
-        expect(_out.type).toBe(LiberoReplacementTypeEnum.LIBERO_OUT);
-        expect(_in.eventType).toBe(EventTypeEnum.LIBERO_REPLACEMENT);
-    });
-});
+import { beforeEach, describe, expect, test } from '@jest/globals';
+import { EventTypeEnum } from './rally-event';
+import { players } from '../player/__stubs__';
+import { LiberoReplacement, LiberoReplacementTypeEnum } from './libero-replacement';
+import { v4 as uuidv4 } from 'uuid';
+describe('LiberoReplacement Test Module', () => {
+    let _in;
+    let _out;
+    beforeEach(() => {
+        _in = new LiberoReplacement({
+            id: uuidv4(),
+            order: 1,
+            player: players[0],
+            libero: players[1],
+            type: LiberoReplacementTypeEnum.LIBERO_IN,
+            eventType: EventTypeEnum.LIBERO_REPLACEMENT
+        });
+        _out = new LiberoReplacement({
+            id: uuidv4(),
+            order: 1,
+            player: players[0],
+            libero: players[1],
+            type: LiberoReplacementTypeEnum.LIBERO_OUT,
+            eventType: EventTypeEnum.LIBERO_REPLACEMENT
+        });
+    });
+    test('Should instantiate object properly', () => {
+        expect(_in.libero.id).toBe('e92f4abb-66f4-4b6c-a602-258404d04484');
+        expect(_in.player.id).toBe('622c36dc-f2d2-44b3-a744-667ea53218b7');
+        expect(_in.type).toBe(LiberoReplacementTypeEnum.LIBERO_IN);
+        expect(_out.type).toBe(LiberoReplacementTypeEnum.LIBERO_OUT);
+        expect(_in.eventType).toBe(EventTypeEnum.LIBERO_REPLACEMENT);
+    });
+});

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

@@ -1,24 +1,24 @@
-import { Player } from '../player';
-export declare enum EventTypeEnum {
-    LIBERO_REPLACEMENT = 0,
-    SUBSTITUTION = 1,
-    SERVE = 2,
-    RECEPTION = 3,
-    SET = 4,
-    SPIKE = 5,
-    BLOCK = 6,
-    SCORE = 7
-}
-export interface RallyEventOpts {
-    readonly id: string;
-    readonly player: Player;
-    readonly eventType: EventTypeEnum;
-    readonly order: number;
-}
-export declare abstract class RallyEvent {
-    readonly id: string;
-    readonly order: number;
-    readonly player: Player;
-    readonly eventType: EventTypeEnum;
-    protected constructor({ id, eventType, player, order }: RallyEventOpts);
-}
+import { Player } from '../player';
+export declare enum EventTypeEnum {
+    LIBERO_REPLACEMENT = 0,
+    SUBSTITUTION = 1,
+    SERVE = 2,
+    RECEPTION = 3,
+    SET = 4,
+    SPIKE = 5,
+    BLOCK = 6,
+    SCORE = 7
+}
+export interface RallyEventOpts {
+    readonly id: string;
+    readonly player: Player;
+    readonly eventType: EventTypeEnum;
+    readonly order: number;
+}
+export declare abstract class RallyEvent {
+    readonly id: string;
+    readonly order: number;
+    readonly player: Player;
+    readonly eventType: EventTypeEnum;
+    protected constructor({ id, eventType, player, order }: RallyEventOpts);
+}

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

@@ -1,19 +1,19 @@
-export var EventTypeEnum;
-(function (EventTypeEnum) {
-    EventTypeEnum[EventTypeEnum["LIBERO_REPLACEMENT"] = 0] = "LIBERO_REPLACEMENT";
-    EventTypeEnum[EventTypeEnum["SUBSTITUTION"] = 1] = "SUBSTITUTION";
-    EventTypeEnum[EventTypeEnum["SERVE"] = 2] = "SERVE";
-    EventTypeEnum[EventTypeEnum["RECEPTION"] = 3] = "RECEPTION";
-    EventTypeEnum[EventTypeEnum["SET"] = 4] = "SET";
-    EventTypeEnum[EventTypeEnum["SPIKE"] = 5] = "SPIKE";
-    EventTypeEnum[EventTypeEnum["BLOCK"] = 6] = "BLOCK";
-    EventTypeEnum[EventTypeEnum["SCORE"] = 7] = "SCORE";
-})(EventTypeEnum || (EventTypeEnum = {}));
-export class RallyEvent {
-    constructor({ id, eventType, player, order }) {
-        this.id = id;
-        this.player = player;
-        this.order = order;
-        this.eventType = eventType;
-    }
-}
+export var EventTypeEnum;
+(function (EventTypeEnum) {
+    EventTypeEnum[EventTypeEnum["LIBERO_REPLACEMENT"] = 0] = "LIBERO_REPLACEMENT";
+    EventTypeEnum[EventTypeEnum["SUBSTITUTION"] = 1] = "SUBSTITUTION";
+    EventTypeEnum[EventTypeEnum["SERVE"] = 2] = "SERVE";
+    EventTypeEnum[EventTypeEnum["RECEPTION"] = 3] = "RECEPTION";
+    EventTypeEnum[EventTypeEnum["SET"] = 4] = "SET";
+    EventTypeEnum[EventTypeEnum["SPIKE"] = 5] = "SPIKE";
+    EventTypeEnum[EventTypeEnum["BLOCK"] = 6] = "BLOCK";
+    EventTypeEnum[EventTypeEnum["SCORE"] = 7] = "SCORE";
+})(EventTypeEnum || (EventTypeEnum = {}));
+export class RallyEvent {
+    constructor({ id, eventType, player, order }) {
+        this.id = id;
+        this.player = player;
+        this.order = order;
+        this.eventType = eventType;
+    }
+}

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

@@ -1,26 +1,26 @@
-import { PerformanceStats, Trait } from '../player';
-import { InPlayEvent, InPlayEventOpts } from './in-play-event';
-export declare enum ReceptionTypeEnum {
-    DIG = 0,
-    OVERHAND = 1,
-    ONE_HAND = 2,
-    OTHER_BODY_PART = 3
-}
-export declare enum ReceptionFailureEnum {
-    NO_FAILURE = 0,
-    FAULT = 1,
-    MISS = 2,
-    OUT_OF_BOUNDS = 3,
-    BAD_PASS = 4
-}
-interface ReceptionOpts extends InPlayEventOpts {
-    readonly type: ReceptionTypeEnum;
-    readonly failure: ReceptionFailureEnum;
-}
-export declare class Reception extends InPlayEvent {
-    readonly failure: ReceptionFailureEnum;
-    readonly type: ReceptionTypeEnum;
-    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }: ReceptionOpts);
-    static getScore(stats: PerformanceStats, type: ReceptionTypeEnum, modifier: number, activeTraits: Trait[]): number;
-}
-export {};
+import { PerformanceStats, Trait } from '../player';
+import { InPlayEvent, InPlayEventOpts } from './in-play-event';
+export declare enum ReceptionTypeEnum {
+    DIG = 0,
+    OVERHAND = 1,
+    ONE_HAND = 2,
+    OTHER_BODY_PART = 3
+}
+export declare enum ReceptionFailureEnum {
+    NO_FAILURE = 0,
+    FAULT = 1,
+    MISS = 2,
+    OUT_OF_BOUNDS = 3,
+    BAD_PASS = 4
+}
+interface ReceptionOpts extends InPlayEventOpts {
+    readonly type: ReceptionTypeEnum;
+    readonly failure: ReceptionFailureEnum;
+}
+export declare class Reception extends InPlayEvent {
+    readonly failure: ReceptionFailureEnum;
+    readonly type: ReceptionTypeEnum;
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }: ReceptionOpts);
+    static getScore(stats: PerformanceStats, type: ReceptionTypeEnum, modifier: number, activeTraits: Trait[]): number;
+}
+export {};

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

@@ -1,36 +1,36 @@
-import { Trait } from '../player';
-import { InPlayEvent } from './in-play-event';
-export var ReceptionTypeEnum;
-(function (ReceptionTypeEnum) {
-    ReceptionTypeEnum[ReceptionTypeEnum["DIG"] = 0] = "DIG";
-    ReceptionTypeEnum[ReceptionTypeEnum["OVERHAND"] = 1] = "OVERHAND";
-    ReceptionTypeEnum[ReceptionTypeEnum["ONE_HAND"] = 2] = "ONE_HAND";
-    ReceptionTypeEnum[ReceptionTypeEnum["OTHER_BODY_PART"] = 3] = "OTHER_BODY_PART";
-})(ReceptionTypeEnum || (ReceptionTypeEnum = {}));
-export var ReceptionFailureEnum;
-(function (ReceptionFailureEnum) {
-    ReceptionFailureEnum[ReceptionFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
-    ReceptionFailureEnum[ReceptionFailureEnum["FAULT"] = 1] = "FAULT";
-    ReceptionFailureEnum[ReceptionFailureEnum["MISS"] = 2] = "MISS";
-    ReceptionFailureEnum[ReceptionFailureEnum["OUT_OF_BOUNDS"] = 3] = "OUT_OF_BOUNDS";
-    ReceptionFailureEnum[ReceptionFailureEnum["BAD_PASS"] = 4] = "BAD_PASS";
-})(ReceptionFailureEnum || (ReceptionFailureEnum = {}));
-export class Reception extends InPlayEvent {
-    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
-        super({ id, order, score, player, target, eventType, modifier, activeTraits });
-        this.type = type;
-        this.failure = failure;
-    }
-    static getScore(stats, type, modifier, activeTraits) {
-        let score = Reception.calculateScore(stats, 'RECEPTION', ReceptionTypeEnum[type]) * modifier;
-        for (const trait of activeTraits) {
-            switch (true) {
-                case trait === Trait.GUARDIAN: {
-                    score *= Trait.GUARDIAN.modifier;
-                    break;
-                }
-            }
-        }
-        return score;
-    }
-}
+import { Trait } from '../player';
+import { InPlayEvent } from './in-play-event';
+export var ReceptionTypeEnum;
+(function (ReceptionTypeEnum) {
+    ReceptionTypeEnum[ReceptionTypeEnum["DIG"] = 0] = "DIG";
+    ReceptionTypeEnum[ReceptionTypeEnum["OVERHAND"] = 1] = "OVERHAND";
+    ReceptionTypeEnum[ReceptionTypeEnum["ONE_HAND"] = 2] = "ONE_HAND";
+    ReceptionTypeEnum[ReceptionTypeEnum["OTHER_BODY_PART"] = 3] = "OTHER_BODY_PART";
+})(ReceptionTypeEnum || (ReceptionTypeEnum = {}));
+export var ReceptionFailureEnum;
+(function (ReceptionFailureEnum) {
+    ReceptionFailureEnum[ReceptionFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
+    ReceptionFailureEnum[ReceptionFailureEnum["FAULT"] = 1] = "FAULT";
+    ReceptionFailureEnum[ReceptionFailureEnum["MISS"] = 2] = "MISS";
+    ReceptionFailureEnum[ReceptionFailureEnum["OUT_OF_BOUNDS"] = 3] = "OUT_OF_BOUNDS";
+    ReceptionFailureEnum[ReceptionFailureEnum["BAD_PASS"] = 4] = "BAD_PASS";
+})(ReceptionFailureEnum || (ReceptionFailureEnum = {}));
+export class Reception extends InPlayEvent {
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ id, order, score, player, target, eventType, modifier, activeTraits });
+        this.type = type;
+        this.failure = failure;
+    }
+    static getScore(stats, type, modifier, activeTraits) {
+        let score = Reception.calculateScore(stats, 'RECEPTION', ReceptionTypeEnum[type]) * modifier;
+        for (const trait of activeTraits) {
+            switch (true) {
+                case trait === Trait.GUARDIAN: {
+                    score *= Trait.GUARDIAN.modifier;
+                    break;
+                }
+            }
+        }
+        return score;
+    }
+}

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

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

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

@@ -1,49 +1,49 @@
-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);
-    });
-});
+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 +1,13 @@
-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 {};
+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 +1,10 @@
-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}]`;
-    }
-}
+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 +1 @@
-export {};
+export {};

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

@@ -1,26 +1,26 @@
-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]');
-    });
-});
+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]');
+    });
+});