volleyballsimtypes 0.0.8 → 0.0.9

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

@@ -0,0 +1,47 @@
+import { describe, expect, test } from '@jest/globals';
+import { Reception, ReceptionFailure, ReceptionType } from './reception';
+import { player } from '../player/__stubs__';
+import { CourtTarget } from '../match';
+import { EventType } 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: CourtTarget.OPPONENT_RIGHT_BACK,
+            failure: ReceptionFailure.NO_FAILURE,
+            type: ReceptionType.DIG,
+            eventType: EventType.RECEPTION,
+            modifier: 1
+        });
+        failed = new Reception({
+            score: 60,
+            id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
+            order: 0,
+            player: player,
+            target: CourtTarget.NO_TARGET,
+            failure: ReceptionFailure.OUT_OF_BOUNDS,
+            type: ReceptionType.OTHER_BODY_PART,
+            eventType: EventType.RECEPTION,
+            modifier: 1
+        });
+    });
+    test('Should instantiate object properly', () => {
+        expect(reception.target).toBe(CourtTarget.OPPONENT_RIGHT_BACK);
+        expect(reception.type).toBe(ReceptionType.DIG);
+        expect(reception.eventType).toBe(EventType.RECEPTION);
+        expect(reception.player.id).toBe(player.id);
+        expect(reception.failure).toBe(ReceptionFailure.NO_FAILURE);
+        expect(failed.failure).toBe(ReceptionFailure.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

@@ -0,0 +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 {};

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

@@ -0,0 +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}]`;
+    }
+}

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

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

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

@@ -0,0 +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 { EventType } from './rally-event';
+describe('Score Test Module', () => {
+    let score;
+    beforeEach(() => {
+        score = new Score({
+            id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
+            order: 0,
+            eventType: EventType.SCORE,
+            player: player,
+            team
+        });
+    });
+    test('Should instantiate object properly', () => {
+        expect(score.eventType).toBe(EventType.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.d.ts

@@ -0,0 +1,27 @@
+import { InPlayEvent, InPlayEventOpts } from './in-play-event';
+import { PerformanceStats } from '../player';
+export declare enum ServeType {
+    UNDERHAND = 0,
+    OVERHAND_TOPSPIN = 1,
+    OVERHAND_FLOAT = 2,
+    JUMP_TOPSPIN = 3,
+    JUMP_FLOAT = 4
+}
+export declare enum ServeFailure {
+    NO_FAILURE = 0,
+    FAULT = 1,
+    MISS = 2,
+    NET = 3,
+    OUT_OF_BOUNDS = 4
+}
+interface ServeOpts extends InPlayEventOpts {
+    readonly type: ServeType;
+    readonly failure: ServeFailure;
+}
+export declare class Serve extends InPlayEvent {
+    readonly failure: ServeFailure;
+    readonly type: ServeType;
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier }: ServeOpts);
+    static getScore(stats: PerformanceStats, type: ServeType, modifier: number): number;
+}
+export {};

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

@@ -0,0 +1,27 @@
+import { InPlayEvent } from './in-play-event';
+export var ServeType;
+(function (ServeType) {
+    ServeType[ServeType["UNDERHAND"] = 0] = "UNDERHAND";
+    ServeType[ServeType["OVERHAND_TOPSPIN"] = 1] = "OVERHAND_TOPSPIN";
+    ServeType[ServeType["OVERHAND_FLOAT"] = 2] = "OVERHAND_FLOAT";
+    ServeType[ServeType["JUMP_TOPSPIN"] = 3] = "JUMP_TOPSPIN";
+    ServeType[ServeType["JUMP_FLOAT"] = 4] = "JUMP_FLOAT";
+})(ServeType || (ServeType = {}));
+export var ServeFailure;
+(function (ServeFailure) {
+    ServeFailure[ServeFailure["NO_FAILURE"] = 0] = "NO_FAILURE";
+    ServeFailure[ServeFailure["FAULT"] = 1] = "FAULT";
+    ServeFailure[ServeFailure["MISS"] = 2] = "MISS";
+    ServeFailure[ServeFailure["NET"] = 3] = "NET";
+    ServeFailure[ServeFailure["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
+})(ServeFailure || (ServeFailure = {}));
+export class Serve extends InPlayEvent {
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier }) {
+        super({ id, order, score, player, target, eventType, modifier });
+        this.type = type;
+        this.failure = failure;
+    }
+    static getScore(stats, type, modifier) {
+        return Serve.calculateScore(stats, 'SERVE', ServeType[type]) * modifier;
+    }
+}

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

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

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

@@ -0,0 +1,47 @@
+import { describe, expect, test } from '@jest/globals';
+import { Serve, ServeFailure, ServeType } from './serve';
+import { player } from '../player/__stubs__';
+import { CourtTarget } from '../match';
+import { EventType } 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: CourtTarget.OPPONENT_RIGHT_BACK,
+            failure: ServeFailure.NO_FAILURE,
+            type: ServeType.JUMP_TOPSPIN,
+            eventType: EventType.SERVE,
+            modifier: 1
+        });
+        failed = new Serve({
+            score: 60,
+            id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
+            order: 0,
+            player: player,
+            target: CourtTarget.NO_TARGET,
+            failure: ServeFailure.NET,
+            type: ServeType.UNDERHAND,
+            eventType: EventType.SERVE,
+            modifier: 1
+        });
+    });
+    test('Should instantiate object properly', () => {
+        expect(serve.target).toBe(CourtTarget.OPPONENT_RIGHT_BACK);
+        expect(serve.type).toBe(ServeType.JUMP_TOPSPIN);
+        expect(serve.eventType).toBe(EventType.SERVE);
+        expect(serve.player.id).toBe(player.id);
+        expect(serve.failure).toBe(ServeFailure.NO_FAILURE);
+        expect(failed.failure).toBe(ServeFailure.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.d.ts

@@ -0,0 +1,26 @@
+import { PerformanceStats } from '../player';
+import { InPlayEvent, InPlayEventOpts } from './in-play-event';
+export declare enum SetType {
+    OVERHAND = 0,
+    UNDERHAND = 1,
+    SPIKE = 2,
+    DUMP = 3
+}
+export declare enum SetFailure {
+    NO_FAILURE = 0,
+    FAULT = 1,
+    MISS = 2,
+    BAD_PASS = 3,
+    OUT_OF_BOUNDS = 4
+}
+interface SetOpts extends InPlayEventOpts {
+    readonly type: SetType;
+    readonly failure: SetFailure;
+}
+export declare class Set extends InPlayEvent {
+    readonly failure: SetFailure;
+    readonly type: SetType;
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier }: SetOpts);
+    static getScore(stats: PerformanceStats, type: SetType, modifier: number): number;
+}
+export {};

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

@@ -0,0 +1,26 @@
+import { InPlayEvent } from './in-play-event';
+export var SetType;
+(function (SetType) {
+    SetType[SetType["OVERHAND"] = 0] = "OVERHAND";
+    SetType[SetType["UNDERHAND"] = 1] = "UNDERHAND";
+    SetType[SetType["SPIKE"] = 2] = "SPIKE";
+    SetType[SetType["DUMP"] = 3] = "DUMP";
+})(SetType || (SetType = {}));
+export var SetFailure;
+(function (SetFailure) {
+    SetFailure[SetFailure["NO_FAILURE"] = 0] = "NO_FAILURE";
+    SetFailure[SetFailure["FAULT"] = 1] = "FAULT";
+    SetFailure[SetFailure["MISS"] = 2] = "MISS";
+    SetFailure[SetFailure["BAD_PASS"] = 3] = "BAD_PASS";
+    SetFailure[SetFailure["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
+})(SetFailure || (SetFailure = {}));
+export class Set extends InPlayEvent {
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier }) {
+        super({ id, order, score, player, target, eventType, modifier });
+        this.type = type;
+        this.failure = failure;
+    }
+    static getScore(stats, type, modifier) {
+        return Set.calculateScore(stats, 'SET', SetType[type]) * modifier;
+    }
+}

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

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

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

@@ -0,0 +1,47 @@
+import { describe, expect, test } from '@jest/globals';
+import { Set, SetFailure, SetType } from './set';
+import { player } from '../player/__stubs__';
+import { CourtTarget } from '../match';
+import { EventType } 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: CourtTarget.OPPONENT_RIGHT_BACK,
+            failure: SetFailure.NO_FAILURE,
+            type: SetType.OVERHAND,
+            eventType: EventType.SET,
+            modifier: 1
+        });
+        failed = new Set({
+            score: 60,
+            id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
+            order: 0,
+            player: player,
+            target: CourtTarget.NO_TARGET,
+            failure: SetFailure.OUT_OF_BOUNDS,
+            type: SetType.DUMP,
+            eventType: EventType.SET,
+            modifier: 1
+        });
+    });
+    test('Should instantiate object properly', () => {
+        expect(set.target).toBe(CourtTarget.OPPONENT_RIGHT_BACK);
+        expect(set.type).toBe(SetType.OVERHAND);
+        expect(set.eventType).toBe(EventType.SET);
+        expect(set.player.id).toBe(player.id);
+        expect(set.failure).toBe(SetFailure.NO_FAILURE);
+        expect(failed.failure).toBe(SetFailure.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.d.ts

@@ -0,0 +1,28 @@
+import { InPlayEvent, InPlayEventOpts } from './in-play-event';
+import { Player } from '../player';
+export declare enum SpikeType {
+    CROSS_SHOT = 0,
+    LINE_SHOT = 1,
+    TOOL_SHOT = 2,
+    TIP = 3,
+    DOWN_BALL = 4,
+    OVERHAND = 5
+}
+export declare enum SpikeFailure {
+    NO_FAILURE = 0,
+    FAULT = 1,
+    MISS = 2,
+    OUT_OF_BOUNDS = 3,
+    NET = 4
+}
+interface SpikeOpts extends InPlayEventOpts {
+    readonly type: SpikeType;
+    readonly failure: SpikeFailure;
+}
+export declare class Spike extends InPlayEvent {
+    readonly failure: SpikeFailure;
+    readonly type: SpikeType;
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier }: SpikeOpts);
+    static getScore(player: Player, type: SpikeType, modifier: number, isBackRow: boolean): number;
+}
+export {};

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

@@ -0,0 +1,32 @@
+import { InPlayEvent } from './in-play-event';
+export var SpikeType;
+(function (SpikeType) {
+    SpikeType[SpikeType["CROSS_SHOT"] = 0] = "CROSS_SHOT";
+    SpikeType[SpikeType["LINE_SHOT"] = 1] = "LINE_SHOT";
+    SpikeType[SpikeType["TOOL_SHOT"] = 2] = "TOOL_SHOT";
+    SpikeType[SpikeType["TIP"] = 3] = "TIP";
+    SpikeType[SpikeType["DOWN_BALL"] = 4] = "DOWN_BALL";
+    SpikeType[SpikeType["OVERHAND"] = 5] = "OVERHAND";
+})(SpikeType || (SpikeType = {}));
+export var SpikeFailure;
+(function (SpikeFailure) {
+    SpikeFailure[SpikeFailure["NO_FAILURE"] = 0] = "NO_FAILURE";
+    SpikeFailure[SpikeFailure["FAULT"] = 1] = "FAULT";
+    SpikeFailure[SpikeFailure["MISS"] = 2] = "MISS";
+    SpikeFailure[SpikeFailure["OUT_OF_BOUNDS"] = 3] = "OUT_OF_BOUNDS";
+    SpikeFailure[SpikeFailure["NET"] = 4] = "NET";
+})(SpikeFailure || (SpikeFailure = {}));
+export class Spike extends InPlayEvent {
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier }) {
+        super({ id, order, score, player, target, eventType, modifier });
+        this.type = type;
+        this.failure = failure;
+    }
+    static getScore(player, type, modifier, isBackRow) {
+        let score = Spike.calculateScore(player.stats, 'SPIKE', SpikeType[type]);
+        if (![SpikeType.DOWN_BALL, SpikeType.OVERHAND, SpikeType.TIP].includes(type) && isBackRow) {
+            score = score * 0.7 + player.stats.backAttack * 0.3;
+        }
+        return score * modifier;
+    }
+}

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

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

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

@@ -0,0 +1,61 @@
+import { describe, expect, test } from '@jest/globals';
+import { Spike, SpikeFailure, SpikeType } from './spike';
+import { player } from '../player/__stubs__';
+import { CourtTarget } from '../match';
+import { EventType } 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: CourtTarget.OPPONENT_RIGHT_BACK,
+            failure: SpikeFailure.NO_FAILURE,
+            type: SpikeType.CROSS_SHOT,
+            eventType: EventType.SPIKE,
+            modifier: 1,
+            score: Spike.getScore(player, SpikeType.CROSS_SHOT, 1, false)
+        });
+        failed = new Spike({
+            id: uuidv4(),
+            order: 1,
+            player: player,
+            target: CourtTarget.NO_TARGET,
+            failure: SpikeFailure.OUT_OF_BOUNDS,
+            type: SpikeType.TIP,
+            eventType: EventType.SPIKE,
+            modifier: 1,
+            score: Spike.getScore(player, SpikeType.TIP, 1, false)
+        });
+        backAttack = new Spike({
+            id: uuidv4(),
+            order: 1,
+            player: player,
+            target: CourtTarget.OPPONENT_RIGHT_BACK,
+            failure: SpikeFailure.NO_FAILURE,
+            type: SpikeType.CROSS_SHOT,
+            eventType: EventType.SPIKE,
+            modifier: 1,
+            score: Spike.getScore(player, SpikeType.CROSS_SHOT, 1, true)
+        });
+    });
+    test('Should instantiate object properly', () => {
+        expect(spike.target).toBe(CourtTarget.OPPONENT_RIGHT_BACK);
+        expect(spike.type).toBe(SpikeType.CROSS_SHOT);
+        expect(spike.eventType).toBe(EventType.SPIKE);
+        expect(spike.player.id).toBe(player.id);
+        expect(spike.failure).toBe(SpikeFailure.NO_FAILURE);
+        expect(failed.failure).toBe(SpikeFailure.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/event/substitution.d.ts

@@ -0,0 +1,9 @@
+import { RallyEvent, RallyEventOpts } from './rally-event';
+import { Player } from '../player';
+export interface SubstitutionOpts extends RallyEventOpts {
+    readonly playerOut: Player;
+}
+export declare class Substitution extends RallyEvent {
+    readonly playerOut: Player;
+    constructor({ id, order, playerOut, player, eventType }: SubstitutionOpts);
+}

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

@@ -0,0 +1,7 @@
+import { RallyEvent } from './rally-event';
+export class Substitution extends RallyEvent {
+    constructor({ id, order, playerOut, player, eventType }) {
+        super({ eventType, player, order, id });
+        this.playerOut = playerOut;
+    }
+}

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

@@ -0,0 +1,18 @@
+import { CourtPosition, CourtRow, CourtTarget, EventStat, Match, MatchSet, MatchSetOpts, MatchSetState, MatchTeam, PlayerPosition, Rally, RallyState, SetStatistics } from './match';
+import { Coach, CoachOpts, Formation, SubPriority } from './coach';
+import { Country, CountryOpts } from './country';
+import { Team, TeamOpts } from './team';
+import { EventType, RallyEvent, RallyEventOpts } from './event/rally-event';
+import { InPlayEvent, InPlayEventOpts } from './event/in-play-event';
+import { Score } from './event/score';
+import { Substitution, SubstitutionOpts } from './event/substitution';
+import { LiberoReplacement, LiberoReplacementOpts, LiberoReplacementType } from './event/libero-replacement';
+import { Serve, ServeFailure, ServeType } from './event/serve';
+import { Reception, ReceptionFailure, ReceptionType } from './event/reception';
+import { Set, SetFailure, SetType } from './event/set';
+import { Spike, SpikeFailure, SpikeType } from './event/spike';
+import { Block, BlockFailure, BlockType } from './event/block';
+import { GeneralStat, Name, PerformanceStats, PerformanceStatsOpts, Player, PlayerOpts, Role, Stat, Trait } from './player';
+import { League, LeagueOpts, Season, SeasonOpts, Standing, StandingOpts } from './league';
+import { formatNumber, generateModifier, getKeys, getRandomEnumValue, randomNumber, shuffle, validateUUID } from './utils';
+export { Block, BlockFailure, BlockType, Coach, CoachOpts, Country, CountryOpts, CourtPosition, CourtRow, CourtTarget, EventStat, EventType, Formation, formatNumber, GeneralStat, generateModifier, getKeys, getRandomEnumValue, InPlayEvent, InPlayEventOpts, League, LeagueOpts, LiberoReplacement, LiberoReplacementOpts, LiberoReplacementType, Match, MatchSet, MatchSetOpts, MatchSetState, MatchTeam, Name, PerformanceStats, PerformanceStatsOpts, Player, PlayerOpts, PlayerPosition, Rally, RallyEvent, RallyEventOpts, RallyState, randomNumber, Reception, ReceptionFailure, ReceptionType, Role, Score, Season, SeasonOpts, Serve, ServeFailure, ServeType, Set, SetFailure, SetStatistics, SetType, shuffle, Spike, SpikeFailure, SpikeType, Standing, StandingOpts, Stat, SubPriority, Substitution, SubstitutionOpts, Team, TeamOpts, Trait, validateUUID };

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

@@ -0,0 +1,18 @@
+import { CourtPosition, CourtRow, CourtTarget, Match, MatchSet, MatchSetState, MatchTeam, Rally, RallyState, } from './match';
+import { Coach, Formation, } from './coach';
+import { Country, } from './country';
+import { Team, } from './team';
+import { EventType, RallyEvent, } from './event/rally-event';
+import { InPlayEvent, } from './event/in-play-event';
+import { Score, } from './event/score';
+import { Substitution, } from './event/substitution';
+import { LiberoReplacement, LiberoReplacementType, } from './event/libero-replacement';
+import { Serve, ServeFailure, ServeType, } from './event/serve';
+import { Reception, ReceptionFailure, ReceptionType, } from './event/reception';
+import { Set, SetFailure, SetType, } from './event/set';
+import { Spike, SpikeFailure, SpikeType, } from './event/spike';
+import { Block, BlockFailure, BlockType, } from './event/block';
+import { GeneralStat, PerformanceStats, Player, Role, Trait, } from './player';
+import { League, Season, Standing, } from './league';
+import { formatNumber, generateModifier, getKeys, getRandomEnumValue, randomNumber, shuffle, validateUUID, } from './utils';
+export { Block, BlockFailure, BlockType, Coach, Country, CourtPosition, CourtRow, CourtTarget, EventType, Formation, formatNumber, GeneralStat, generateModifier, getKeys, getRandomEnumValue, InPlayEvent, League, LiberoReplacement, LiberoReplacementType, Match, MatchSet, MatchSetState, MatchTeam, PerformanceStats, Player, Rally, RallyEvent, RallyState, randomNumber, Reception, ReceptionFailure, ReceptionType, Role, Score, Season, Serve, ServeFailure, ServeType, Set, SetFailure, SetType, shuffle, Spike, SpikeFailure, SpikeType, Standing, Substitution, Team, Trait, validateUUID };

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

@@ -0,0 +1,4 @@
+import { Standing, StandingOpts } from './standing';
+import { Season, SeasonOpts } from './season';
+import { League, LeagueOpts } from './league';
+export { StandingOpts, LeagueOpts, SeasonOpts, Season, Standing, League };

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

@@ -0,0 +1,4 @@
+import { Standing } from './standing';
+import { Season } from './season';
+import { League } from './league';
+export { Season, Standing, League };

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

@@ -0,0 +1,19 @@
+import { Season } from './season';
+import { Country } from '../country';
+import { Team } from '../team';
+import { Match } from '../match';
+export interface LeagueOpts {
+    readonly id: string;
+    readonly name: string;
+    readonly country: Country;
+    readonly seasons: Season[];
+}
+export declare class League {
+    readonly id: string;
+    readonly name: string;
+    readonly seasons: Season[];
+    readonly country: Country;
+    constructor({ id, name, country, seasons }: LeagueOpts);
+    newSeason(teams: Team[]): Season;
+    static generateMatches(teams: Team[], baseDate: Date): Match[];
+}

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

@@ -0,0 +1,80 @@
+import { Season } from './season';
+import { Match } from '../match';
+import moment from 'moment/moment';
+import { shuffle } from '../utils';
+import { v4 as uuidv4 } from 'uuid';
+export class League {
+    constructor({ id, name, country, seasons }) {
+        this.id = id;
+        this.name = name;
+        this.country = country;
+        this.seasons = seasons;
+    }
+    newSeason(teams) {
+        const matches = League.generateMatches(teams, moment().add(4, 'hour').toDate());
+        const season = new Season({
+            id: uuidv4(),
+            iteration: this.seasons.length,
+            teams,
+            matches
+        });
+        this.seasons.push(season);
+        return season;
+    }
+    static generateMatches(teams, baseDate) {
+        const t = new Set(teams.map(x => x.id));
+        const date = moment(baseDate);
+        date.startOf('hour');
+        if (t.size !== teams.length) {
+            throw new Error('DUPLICATE_TEAMS');
+        }
+        let shuffled = shuffle([...teams]);
+        const l = shuffled.length - 1;
+        const half = Math.ceil(shuffled.length / 2);
+        const matches = [];
+        // We fix the first team
+        let firstTeam = shuffled.shift();
+        if (firstTeam == null) {
+            throw new Error('EMPTY_TEAM_ARRAY');
+        }
+        let homeRow;
+        let awayRow;
+        for (let i = 0; i < l; i++) {
+            // split array in 2 halves
+            const row1 = shuffled.slice(0, half);
+            const row2 = shuffled.slice(half);
+            const scheduledDate = date.add(30, 'minutes').toDate();
+            row2.push(firstTeam);
+            if (i % 2 === 0) {
+                homeRow = row1;
+                awayRow = row2;
+            }
+            else {
+                homeRow = row2;
+                awayRow = row1;
+            }
+            for (let j = 0; j < half; j++) {
+                matches.push(new Match({
+                    id: uuidv4(),
+                    homeTeam: homeRow[j],
+                    awayTeam: awayRow[j],
+                    scheduledDate,
+                    sets: []
+                }));
+            }
+            firstTeam = row2.pop();
+            row1.unshift(row2.shift());
+            row2.push(row1.pop());
+            shuffled = [...row1, ...row2];
+        }
+        // Generate Inverted matches for home-away pairings
+        matches.push(...matches.map(match => new Match({
+            id: uuidv4(),
+            homeTeam: match.awayTeam,
+            awayTeam: match.homeTeam,
+            scheduledDate: date.add(30, 'minutes').toDate(),
+            sets: []
+        })));
+        return matches;
+    }
+}

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

@@ -0,0 +1,19 @@
+import { Team } from '../team';
+import { Match } from '../match';
+import { Standing } from './standing';
+export interface SeasonOpts {
+    readonly id: string;
+    readonly teams: Team[];
+    readonly matches: Match[];
+    readonly iteration: number;
+}
+export declare class Season {
+    readonly id: string;
+    readonly teams: Team[];
+    readonly matches: Match[];
+    readonly iteration: number;
+    readonly standings: Standing[];
+    constructor({ id, iteration, teams, matches }: SeasonOpts);
+    calculateStandings(): Standing[];
+    get champion(): Team | undefined;
+}

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

@@ -0,0 +1,22 @@
+import { Standing } from './standing';
+export class Season {
+    constructor({ id, iteration, teams, matches }) {
+        this.id = id;
+        this.teams = teams;
+        this.matches = matches;
+        this.iteration = iteration;
+        this.standings = this.calculateStandings();
+    }
+    calculateStandings() {
+        return this.teams.map(team => {
+            const standing = new Standing({ teamId: team.id });
+            standing.calculateStanding(this.matches);
+            return standing;
+        }).sort(Standing.sortFn);
+    }
+    get champion() {
+        if (this.matches.every(match => !match.isOver()))
+            return undefined;
+        return this.teams.find(team => team.id === this.standings[0].teamId);
+    }
+}