volleyballsimtypes 0.0.120 → 0.0.121

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

@@ -1,17 +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 = {}));
+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.d.ts

@@ -1,26 +1,26 @@
-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[];
-    readonly isSimulated: boolean;
-}
-export declare class Match {
-    static readonly BEST_OF = 5;
-    readonly id: string;
-    readonly homeTeam: Team;
-    readonly awayTeam: Team;
-    readonly sets: MatchSet[];
-    readonly scheduledDate: Date;
-    isSimulated: boolean;
-    constructor({ id, homeTeam, awayTeam, scheduledDate, sets, isSimulated }: MatchOpts);
-    addSet(set: MatchSet): void;
-    getTeamSets(team: MatchTeam): number;
-    isOver(): boolean;
-    getWinner(): Team;
-}
-export {};
+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[];
+    readonly isSimulated: boolean;
+}
+export declare class Match {
+    static readonly BEST_OF = 5;
+    readonly id: string;
+    readonly homeTeam: Team;
+    readonly awayTeam: Team;
+    readonly sets: MatchSet[];
+    readonly scheduledDate: Date;
+    isSimulated: boolean;
+    constructor({ id, homeTeam, awayTeam, scheduledDate, sets, isSimulated }: MatchOpts);
+    addSet(set: MatchSet): void;
+    getTeamSets(team: MatchTeam): number;
+    isOver(): boolean;
+    getWinner(): Team;
+}
+export {};

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

@@ -1,39 +1,39 @@
-import { validateUUID } from '../utils';
-import { MatchTeam } from './match-team';
-export class Match {
-    constructor({ id, homeTeam, awayTeam, scheduledDate, sets, isSimulated }) {
-        validateUUID(id);
-        this.id = id;
-        this.homeTeam = homeTeam;
-        this.awayTeam = awayTeam;
-        this.scheduledDate = scheduledDate;
-        this.sets = sets;
-        this.isSimulated = isSimulated;
-    }
-    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;
+import { validateUUID } from '../utils';
+import { MatchTeam } from './match-team';
+export class Match {
+    constructor({ id, homeTeam, awayTeam, scheduledDate, sets, isSimulated }) {
+        validateUUID(id);
+        this.id = id;
+        this.homeTeam = homeTeam;
+        this.awayTeam = awayTeam;
+        this.scheduledDate = scheduledDate;
+        this.sets = sets;
+        this.isSimulated = isSimulated;
+    }
+    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/rally.d.ts

@@ -1,22 +1,22 @@
-import { Team } from '../team';
-import { CourtPosition } from './court-position';
-import { RallyEvent } from '../event';
-interface RallyOpts {
-    readonly id: string;
-    readonly order: number;
-    readonly servingTeam: Team;
-    readonly events: RallyEvent[];
-}
-export interface PlayerPosition {
-    position: CourtPosition;
-    playerId: string;
-}
-export declare class Rally {
-    readonly id: string;
-    readonly servingTeam: Team;
-    readonly events: RallyEvent[];
-    readonly order: number;
-    constructor({ id, order, servingTeam, events }: RallyOpts);
-    addEvent(event: RallyEvent): void;
-}
-export {};
+import { Team } from '../team';
+import { CourtPosition } from './court-position';
+import { RallyEvent } from '../event';
+interface RallyOpts {
+    readonly id: string;
+    readonly order: number;
+    readonly servingTeam: Team;
+    readonly events: RallyEvent[];
+}
+export interface PlayerPosition {
+    position: CourtPosition;
+    playerId: string;
+}
+export declare class Rally {
+    readonly id: string;
+    readonly servingTeam: Team;
+    readonly events: RallyEvent[];
+    readonly order: number;
+    constructor({ id, order, servingTeam, events }: RallyOpts);
+    addEvent(event: RallyEvent): void;
+}
+export {};

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

@@ -1,13 +1,13 @@
-import { validateUUID } from '../utils';
-export class Rally {
-    constructor({ id, order, servingTeam, events }) {
-        validateUUID(id);
-        this.id = id;
-        this.order = order;
-        this.servingTeam = servingTeam;
-        this.events = events;
-    }
-    addEvent(event) {
-        this.events.push(event);
-    }
-}
+import { validateUUID } from '../utils';
+export class Rally {
+    constructor({ id, order, servingTeam, events }) {
+        validateUUID(id);
+        this.id = id;
+        this.order = order;
+        this.servingTeam = servingTeam;
+        this.events = events;
+    }
+    addEvent(event) {
+        this.events.push(event);
+    }
+}

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

@@ -1,5 +1,5 @@
-export * from './player';
-export * from './performance-stats';
-export * from './role';
-export * from './trait';
-export * from './stats';
+export * from './player';
+export * from './performance-stats';
+export * from './role';
+export * from './trait';
+export * from './stats';

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

@@ -1,5 +1,5 @@
-export * from './player';
-export * from './performance-stats';
-export * from './role';
-export * from './trait';
-export * from './stats';
+export * from './player';
+export * from './performance-stats';
+export * from './role';
+export * from './trait';
+export * from './stats';

package/dist/esm/src/service/player/performance-stats.d.ts

@@ -1,29 +1,29 @@
-interface PerformanceStatsOpts {
-    readonly setting: number;
-    readonly pass: number;
-    readonly reception: number;
-    readonly spike: number;
-    readonly backAttack: number;
-    readonly jump: number;
-    readonly block: number;
-    readonly awareness: number;
-    readonly serve: number;
-    readonly defense: number;
-    readonly stamina: number;
-}
-export declare class PerformanceStats {
-    readonly setting: number;
-    readonly pass: number;
-    readonly reception: number;
-    readonly spike: number;
-    readonly backAttack: number;
-    readonly jump: number;
-    readonly block: number;
-    readonly awareness: number;
-    readonly serve: number;
-    readonly defense: number;
-    readonly stamina: number;
-    constructor(opts: PerformanceStatsOpts);
-    toString(): string;
-}
-export {};
+interface PerformanceStatsOpts {
+    readonly setting: number;
+    readonly pass: number;
+    readonly reception: number;
+    readonly spike: number;
+    readonly backAttack: number;
+    readonly jump: number;
+    readonly block: number;
+    readonly awareness: number;
+    readonly serve: number;
+    readonly defense: number;
+    readonly stamina: number;
+}
+export declare class PerformanceStats {
+    readonly setting: number;
+    readonly pass: number;
+    readonly reception: number;
+    readonly spike: number;
+    readonly backAttack: number;
+    readonly jump: number;
+    readonly block: number;
+    readonly awareness: number;
+    readonly serve: number;
+    readonly defense: number;
+    readonly stamina: number;
+    constructor(opts: PerformanceStatsOpts);
+    toString(): string;
+}
+export {};

package/dist/esm/src/service/player/performance-stats.js

@@ -1,19 +1,19 @@
-import { getKeys } from '../utils';
-export class PerformanceStats {
-    constructor(opts) {
-        this.serve = opts.serve;
-        this.pass = opts.pass;
-        this.setting = opts.setting;
-        this.reception = opts.reception;
-        this.spike = opts.spike;
-        this.backAttack = opts.backAttack;
-        this.jump = opts.jump;
-        this.block = opts.block;
-        this.awareness = opts.awareness;
-        this.defense = opts.defense;
-        this.stamina = opts.stamina;
-    }
-    toString() {
-        return getKeys(this).map(key => `${key}: ${this[key]}`).join(', ');
-    }
-}
+import { getKeys } from '../utils';
+export class PerformanceStats {
+    constructor(opts) {
+        this.serve = opts.serve;
+        this.pass = opts.pass;
+        this.setting = opts.setting;
+        this.reception = opts.reception;
+        this.spike = opts.spike;
+        this.backAttack = opts.backAttack;
+        this.jump = opts.jump;
+        this.block = opts.block;
+        this.awareness = opts.awareness;
+        this.defense = opts.defense;
+        this.stamina = opts.stamina;
+    }
+    toString() {
+        return getKeys(this).map(key => `${key}: ${this[key]}`).join(', ');
+    }
+}

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

@@ -1,35 +1,35 @@
-import { PerformanceStats } from './performance-stats';
-import { Role } from './role';
-import { Trait } from './trait';
-import { Country } from '../country';
-import { GeneralStat } from './stats';
-export interface Stat {
-    name: GeneralStat;
-    value: number;
-}
-interface PlayerOpts {
-    readonly id: string;
-    readonly name: Name;
-    readonly country: Country;
-    readonly stats: PerformanceStats;
-    readonly roles: Role[];
-    readonly traits: Trait[];
-}
-export interface Name {
-    first: string;
-    last: string;
-}
-export declare class Player {
-    readonly id: string;
-    readonly name: Name;
-    readonly country: Country;
-    readonly stats: PerformanceStats;
-    readonly roles: Role[];
-    readonly traits: Trait[];
-    readonly generalStats: Stat[];
-    constructor({ id, name, country, stats, roles, traits }: PlayerOpts);
-    static sortPlayers(roles: Role[]): (p1: Player, p2: Player) => number;
-    static compareStats(p1: Player, p2: Player): number;
-    canPlayLibero(): boolean;
-}
-export {};
+import { PerformanceStats } from './performance-stats';
+import { Role } from './role';
+import { Trait } from './trait';
+import { Country } from '../country';
+import { GeneralStat } from './stats';
+export interface Stat {
+    name: GeneralStat;
+    value: number;
+}
+interface PlayerOpts {
+    readonly id: string;
+    readonly name: Name;
+    readonly country: Country;
+    readonly stats: PerformanceStats;
+    readonly roles: Role[];
+    readonly traits: Trait[];
+}
+export interface Name {
+    first: string;
+    last: string;
+}
+export declare class Player {
+    readonly id: string;
+    readonly name: Name;
+    readonly country: Country;
+    readonly stats: PerformanceStats;
+    readonly roles: Role[];
+    readonly traits: Trait[];
+    readonly generalStats: Stat[];
+    constructor({ id, name, country, stats, roles, traits }: PlayerOpts);
+    static sortPlayers(roles: Role[]): (p1: Player, p2: Player) => number;
+    static compareStats(p1: Player, p2: Player): number;
+    canPlayLibero(): boolean;
+}
+export {};

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

@@ -1,55 +1,55 @@
-import { Role } from './role';
-import { validateUUID } from '../utils';
-import { GeneralStat } from './stats';
-export class Player {
-    constructor({ id, name, country, stats, roles, traits }) {
-        validateUUID(id);
-        this.id = id;
-        this.name = name;
-        this.country = country;
-        this.stats = stats;
-        this.roles = roles;
-        this.traits = traits;
-        this.generalStats = GeneralStat.getStats()
-            .map(stat => ({
-            name: stat,
-            value: GeneralStat.calculateScore(stats, stat)
-        }));
-    }
-    // Used as a base sorting function for players
-    static sortPlayers(roles) {
-        return (p1, p2) => roles.reduce((x, role) => {
-            const p2Score = Role.calculateScore(p2.stats, role);
-            const p1Score = Role.calculateScore(p1.stats, role);
-            return x + p2Score - p1Score;
-        }, 0);
-    }
-    static compareStats(p1, p2) {
-        const compareFn = (acc, current) => {
-            let x = current.value;
-            switch (current.name) {
-                case GeneralStat.ATTACK:
-                    x *= 0.35;
-                    break;
-                case GeneralStat.DEFENSE:
-                    x *= 0.35;
-                    break;
-                case GeneralStat.SERVE:
-                    x *= 0.2;
-                    break;
-                case GeneralStat.PHYSICAL:
-                    x *= 0.1;
-                    break;
-                default:
-                    x *= 0;
-            }
-            return acc + x;
-        };
-        const s1 = p1.generalStats.reduce(compareFn, 0);
-        const s2 = p2.generalStats.reduce(compareFn, 0);
-        return s2 - s1;
-    }
-    canPlayLibero() {
-        return this.roles.includes(Role.LIBERO);
-    }
-}
+import { Role } from './role';
+import { validateUUID } from '../utils';
+import { GeneralStat } from './stats';
+export class Player {
+    constructor({ id, name, country, stats, roles, traits }) {
+        validateUUID(id);
+        this.id = id;
+        this.name = name;
+        this.country = country;
+        this.stats = stats;
+        this.roles = roles;
+        this.traits = traits;
+        this.generalStats = GeneralStat.getStats()
+            .map(stat => ({
+            name: stat,
+            value: GeneralStat.calculateScore(stats, stat)
+        }));
+    }
+    // Used as a base sorting function for players
+    static sortPlayers(roles) {
+        return (p1, p2) => roles.reduce((x, role) => {
+            const p2Score = Role.calculateScore(p2.stats, role);
+            const p1Score = Role.calculateScore(p1.stats, role);
+            return x + p2Score - p1Score;
+        }, 0);
+    }
+    static compareStats(p1, p2) {
+        const compareFn = (acc, current) => {
+            let x = current.value;
+            switch (current.name) {
+                case GeneralStat.ATTACK:
+                    x *= 0.35;
+                    break;
+                case GeneralStat.DEFENSE:
+                    x *= 0.35;
+                    break;
+                case GeneralStat.SERVE:
+                    x *= 0.2;
+                    break;
+                case GeneralStat.PHYSICAL:
+                    x *= 0.1;
+                    break;
+                default:
+                    x *= 0;
+            }
+            return acc + x;
+        };
+        const s1 = p1.generalStats.reduce(compareFn, 0);
+        const s2 = p2.generalStats.reduce(compareFn, 0);
+        return s2 - s1;
+    }
+    canPlayLibero() {
+        return this.roles.includes(Role.LIBERO);
+    }
+}

package/dist/esm/src/service/player/role.d.ts

@@ -1,15 +1,15 @@
-import { PerformanceStats } from './performance-stats';
-export declare class Role {
-    static readonly SETTER: Role;
-    static readonly LIBERO: Role;
-    static readonly OUTSIDE_HITTER: Role;
-    static readonly OPPOSITE_HITTER: Role;
-    static readonly MIDDLE_BLOCKER: Role;
-    static readonly DEFENSIVE_SPECIALIST: Role;
-    private static readonly ROLES;
-    readonly name: string;
-    private constructor();
-    static getRoles(): Role[];
-    static calculateScore(stats: PerformanceStats, role: Role): number;
-    static assignRoles(stats: PerformanceStats): Role[];
-}
+import { PerformanceStats } from './performance-stats';
+export declare class Role {
+    static readonly SETTER: Role;
+    static readonly LIBERO: Role;
+    static readonly OUTSIDE_HITTER: Role;
+    static readonly OPPOSITE_HITTER: Role;
+    static readonly MIDDLE_BLOCKER: Role;
+    static readonly DEFENSIVE_SPECIALIST: Role;
+    private static readonly ROLES;
+    readonly name: string;
+    private constructor();
+    static getRoles(): Role[];
+    static calculateScore(stats: PerformanceStats, role: Role): number;
+    static assignRoles(stats: PerformanceStats): Role[];
+}

package/dist/esm/src/service/player/role.js

@@ -1,39 +1,39 @@
-import roleWeights from '../../../data/role.formula.json';
-export class Role {
-    constructor(name) {
-        this.name = name;
-    }
-    static getRoles() {
-        return [...Role.ROLES];
-    }
-    static calculateScore(stats, role) {
-        const weights = roleWeights.find(r => r.role === role.name);
-        if (weights == null)
-            throw new Error('COULD_NOT_FIND_ROLE_WEIGHT');
-        const score = Object.entries(weights.weight)
-            .reduce((score, [key, value]) => score + (stats[key] * weights.weight[key]), 0);
-        return Math.round(score);
-    }
-    static assignRoles(stats) {
-        const scores = this.getRoles().map(role => ({
-            role,
-            score: this.calculateScore(stats, role)
-        })).sort((x, y) => y.score - x.score);
-        const out = [scores[0].role];
-        if (scores[1].score >= 65) {
-            out.push(scores[1].role);
-        }
-        if (scores[2].score >= 70) {
-            out.push(scores[2].role);
-        }
-        return out;
-    }
-}
-Role.SETTER = new Role('Setter');
-Role.LIBERO = new Role('Libero');
-Role.OUTSIDE_HITTER = new Role('Outside Hitter');
-Role.OPPOSITE_HITTER = new Role('Opposite Hitter');
-Role.MIDDLE_BLOCKER = new Role('Middle Blocker');
-Role.DEFENSIVE_SPECIALIST = new Role('Defensive Specialist');
-Role.ROLES = [Role.LIBERO, Role.SETTER, Role.OPPOSITE_HITTER, Role.OUTSIDE_HITTER, Role.MIDDLE_BLOCKER,
-    Role.DEFENSIVE_SPECIALIST];
+import roleWeights from '../../../data/role.formula.json';
+export class Role {
+    constructor(name) {
+        this.name = name;
+    }
+    static getRoles() {
+        return [...Role.ROLES];
+    }
+    static calculateScore(stats, role) {
+        const weights = roleWeights.find(r => r.role === role.name);
+        if (weights == null)
+            throw new Error('COULD_NOT_FIND_ROLE_WEIGHT');
+        const score = Object.entries(weights.weight)
+            .reduce((score, [key, value]) => score + (stats[key] * weights.weight[key]), 0);
+        return Math.round(score);
+    }
+    static assignRoles(stats) {
+        const scores = this.getRoles().map(role => ({
+            role,
+            score: this.calculateScore(stats, role)
+        })).sort((x, y) => y.score - x.score);
+        const out = [scores[0].role];
+        if (scores[1].score >= 65) {
+            out.push(scores[1].role);
+        }
+        if (scores[2].score >= 70) {
+            out.push(scores[2].role);
+        }
+        return out;
+    }
+}
+Role.SETTER = new Role('Setter');
+Role.LIBERO = new Role('Libero');
+Role.OUTSIDE_HITTER = new Role('Outside Hitter');
+Role.OPPOSITE_HITTER = new Role('Opposite Hitter');
+Role.MIDDLE_BLOCKER = new Role('Middle Blocker');
+Role.DEFENSIVE_SPECIALIST = new Role('Defensive Specialist');
+Role.ROLES = [Role.LIBERO, Role.SETTER, Role.OPPOSITE_HITTER, Role.OUTSIDE_HITTER, Role.MIDDLE_BLOCKER,
+    Role.DEFENSIVE_SPECIALIST];