volleyballsimtypes 0.0.174 → 0.0.176

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Serve = exports.ServeFailureEnum = exports.ServeTypeEnum = void 0;
+const rally_event_1 = require("./rally-event");
+const in_play_event_1 = require("./in-play-event");
+var ServeTypeEnum;
+(function (ServeTypeEnum) {
+    ServeTypeEnum[ServeTypeEnum["OVERHAND_TOPSPIN"] = 0] = "OVERHAND_TOPSPIN";
+    ServeTypeEnum[ServeTypeEnum["OVERHAND_FLOAT"] = 1] = "OVERHAND_FLOAT";
+    ServeTypeEnum[ServeTypeEnum["JUMP_TOPSPIN"] = 2] = "JUMP_TOPSPIN";
+    ServeTypeEnum[ServeTypeEnum["JUMP_FLOAT"] = 3] = "JUMP_FLOAT";
+})(ServeTypeEnum = exports.ServeTypeEnum || (exports.ServeTypeEnum = {}));
+var ServeFailureEnum;
+(function (ServeFailureEnum) {
+    ServeFailureEnum[ServeFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
+    ServeFailureEnum[ServeFailureEnum["FAULT"] = 1] = "FAULT";
+    ServeFailureEnum[ServeFailureEnum["MISS"] = 2] = "MISS";
+    ServeFailureEnum[ServeFailureEnum["NET"] = 3] = "NET";
+    ServeFailureEnum[ServeFailureEnum["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
+})(ServeFailureEnum = exports.ServeFailureEnum || (exports.ServeFailureEnum = {}));
+const eventType = rally_event_1.EventTypeEnum.SERVE;
+class Serve extends in_play_event_1.InPlayEvent {
+    constructor({ score, playerId, target, failure, type, activeTraits }) {
+        super({ score, playerId, target, activeTraits, eventType });
+        this.type = type;
+        this.failure = failure;
+    }
+    toString() {
+        const failure = `"failure":${this.failure}`;
+        const type = `"type":${this.type}`;
+        return `{${this._toString()},${failure},${type}}`;
+    }
+}
+exports.Serve = Serve;

package/dist/cjs/src/service/event/set.d.ts

@@ -0,0 +1,31 @@
+import { CourtTarget } from '../match';
+import { Trait } from '../player';
+import { InPlayEvent } from './in-play-event';
+export declare enum SetTypeEnum {
+    OVERHAND = 0,
+    DUMP = 1
+}
+export type SetType = SetTypeEnum.OVERHAND | SetTypeEnum.DUMP;
+export declare enum SetFailureEnum {
+    NO_FAILURE = 0,
+    FAULT = 1,
+    MISS = 2,
+    BAD_PASS = 3,
+    OUT_OF_BOUNDS = 4
+}
+export type SetFailure = SetFailureEnum.NO_FAILURE | SetFailureEnum.FAULT | SetFailureEnum.MISS | SetFailureEnum.BAD_PASS | SetFailureEnum.OUT_OF_BOUNDS;
+interface SetOpts {
+    readonly type: SetType;
+    readonly failure: SetFailure;
+    readonly target: CourtTarget;
+    readonly score: number;
+    readonly activeTraits: Trait[];
+    readonly playerId: string;
+}
+export declare class Set extends InPlayEvent<SetFailure, SetType> {
+    readonly failure: SetFailure;
+    readonly type: SetType;
+    constructor({ score, playerId, target, failure, type, activeTraits }: SetOpts);
+    toString(): string;
+}
+export {};

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Set = exports.SetFailureEnum = exports.SetTypeEnum = void 0;
+const rally_event_1 = require("./rally-event");
+const in_play_event_1 = require("./in-play-event");
+var SetTypeEnum;
+(function (SetTypeEnum) {
+    SetTypeEnum[SetTypeEnum["OVERHAND"] = 0] = "OVERHAND";
+    SetTypeEnum[SetTypeEnum["DUMP"] = 1] = "DUMP";
+})(SetTypeEnum = exports.SetTypeEnum || (exports.SetTypeEnum = {}));
+var SetFailureEnum;
+(function (SetFailureEnum) {
+    SetFailureEnum[SetFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
+    SetFailureEnum[SetFailureEnum["FAULT"] = 1] = "FAULT";
+    SetFailureEnum[SetFailureEnum["MISS"] = 2] = "MISS";
+    SetFailureEnum[SetFailureEnum["BAD_PASS"] = 3] = "BAD_PASS";
+    SetFailureEnum[SetFailureEnum["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
+})(SetFailureEnum = exports.SetFailureEnum || (exports.SetFailureEnum = {}));
+const eventType = rally_event_1.EventTypeEnum.SET;
+class Set extends in_play_event_1.InPlayEvent {
+    constructor({ score, playerId, target, failure, type, activeTraits }) {
+        super({ score, playerId, target, activeTraits, eventType });
+        this.type = type;
+        this.failure = failure;
+    }
+    toString() {
+        const failure = `"failure":${this.failure}`;
+        const type = `"type":${this.type}`;
+        return `{${this._toString()},${failure},${type}}`;
+    }
+}
+exports.Set = Set;

package/dist/cjs/src/service/event/spike.d.ts

@@ -0,0 +1,35 @@
+import { CourtTarget } from '../match';
+import { Trait } from '../player';
+import { InPlayEvent } from './in-play-event';
+export declare enum SpikeTypeEnum {
+    CROSS_SHOT = 0,
+    LINE_SHOT = 1,
+    REVERSE_CROSS = 2,
+    TIP = 3,
+    DOWN_BALL = 4,
+    OVERHAND = 5
+}
+export type SpikeType = SpikeTypeEnum.CROSS_SHOT | SpikeTypeEnum.LINE_SHOT | SpikeTypeEnum.REVERSE_CROSS | SpikeTypeEnum.TIP | SpikeTypeEnum.DOWN_BALL | SpikeTypeEnum.OVERHAND;
+export declare enum SpikeFailureEnum {
+    NO_FAILURE = 0,
+    FAULT = 1,
+    MISS = 2,
+    OUT_OF_BOUNDS = 3,
+    NET = 4
+}
+export type SpikeFailure = SpikeFailureEnum.NO_FAILURE | SpikeFailureEnum.FAULT | SpikeFailureEnum.MISS | SpikeFailureEnum.OUT_OF_BOUNDS | SpikeFailureEnum.NET;
+interface SpikeOpts {
+    readonly type: SpikeType;
+    readonly failure: SpikeFailure;
+    readonly target: CourtTarget;
+    readonly score: number;
+    readonly activeTraits: Trait[];
+    readonly playerId: string;
+}
+export declare class Spike extends InPlayEvent<SpikeFailure, SpikeType> {
+    readonly failure: SpikeFailure;
+    readonly type: SpikeType;
+    constructor({ score, playerId, target, failure, type, activeTraits }: SpikeOpts);
+    toString(): string;
+}
+export {};

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Spike = exports.SpikeFailureEnum = exports.SpikeTypeEnum = void 0;
+const rally_event_1 = require("./rally-event");
+const in_play_event_1 = require("./in-play-event");
+var SpikeTypeEnum;
+(function (SpikeTypeEnum) {
+    SpikeTypeEnum[SpikeTypeEnum["CROSS_SHOT"] = 0] = "CROSS_SHOT";
+    SpikeTypeEnum[SpikeTypeEnum["LINE_SHOT"] = 1] = "LINE_SHOT";
+    SpikeTypeEnum[SpikeTypeEnum["REVERSE_CROSS"] = 2] = "REVERSE_CROSS";
+    SpikeTypeEnum[SpikeTypeEnum["TIP"] = 3] = "TIP";
+    SpikeTypeEnum[SpikeTypeEnum["DOWN_BALL"] = 4] = "DOWN_BALL";
+    SpikeTypeEnum[SpikeTypeEnum["OVERHAND"] = 5] = "OVERHAND";
+})(SpikeTypeEnum = exports.SpikeTypeEnum || (exports.SpikeTypeEnum = {}));
+var SpikeFailureEnum;
+(function (SpikeFailureEnum) {
+    SpikeFailureEnum[SpikeFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
+    SpikeFailureEnum[SpikeFailureEnum["FAULT"] = 1] = "FAULT";
+    SpikeFailureEnum[SpikeFailureEnum["MISS"] = 2] = "MISS";
+    SpikeFailureEnum[SpikeFailureEnum["OUT_OF_BOUNDS"] = 3] = "OUT_OF_BOUNDS";
+    SpikeFailureEnum[SpikeFailureEnum["NET"] = 4] = "NET";
+})(SpikeFailureEnum = exports.SpikeFailureEnum || (exports.SpikeFailureEnum = {}));
+const eventType = rally_event_1.EventTypeEnum.SPIKE;
+class Spike extends in_play_event_1.InPlayEvent {
+    constructor({ score, playerId, target, failure, type, activeTraits }) {
+        super({ score, playerId, target, activeTraits, eventType });
+        this.type = type;
+        this.failure = failure;
+    }
+    toString() {
+        const failure = `"failure":${this.failure}`;
+        const type = `"type":${this.type}`;
+        return `{${this._toString()},${failure},${type}}`;
+    }
+}
+exports.Spike = Spike;

package/dist/cjs/src/service/event/substitution.d.ts

@@ -0,0 +1,11 @@
+import { RallyEvent } from './rally-event';
+interface SubstitutionOpts {
+    readonly playerOut: string;
+    readonly playerId: string;
+}
+export declare class Substitution extends RallyEvent {
+    readonly playerOut: string;
+    constructor({ playerOut, playerId }: SubstitutionOpts);
+    toString(): string;
+}
+export {};

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Substitution = void 0;
+const rally_event_1 = require("./rally-event");
+const eventType = rally_event_1.EventTypeEnum.SUBSTITUTION;
+class Substitution extends rally_event_1.RallyEvent {
+    constructor({ playerOut, playerId }) {
+        super({ eventType, playerId });
+        this.playerOut = playerOut;
+    }
+    toString() {
+        const playerId = `"playerId":"${this.playerId}"`;
+        const playerOut = `"playerOut":"${this.playerOut}"`;
+        const eventType = `"eventType":${this.eventType}`;
+        return `{${playerId},${playerOut},${eventType}}`;
+    }
+}
+exports.Substitution = Substitution;

package/dist/cjs/src/service/match/match-set.d.ts

@@ -1,6 +1,5 @@
 import { PlayerPosition, Rally } from './rally';
 import { MatchTeam } from './match-team';
-import { Player } from '../player';
 declare enum ScoreThreshold {
     SET = 25,
     TIE_BREAK = 15
@@ -21,7 +20,8 @@ export interface EventStat {
     error: number;
 }
 export interface SetStatistics {
-    player: Player;
+    readonly playerId: string;
+    order: number;
     ace: number;
     attempts: number;
     contacts: number;
@@ -34,6 +34,7 @@ export interface SetStatistics {
     kills: number;
     killBlocks: number;
     assists: number;
+    setsPlayed: number;
 }
 export declare class MatchSet {
     readonly id: string;
@@ -52,7 +53,7 @@ export declare class MatchSet {
     increaseScore(team: MatchTeam): void;
     addRally(rally: Rally): void;
     /**
-     * Has a team reached at least 25 points and is the score difference between both teams at least 2?
+     * Has a team reached at least 25 points, and is the score difference between both teams at least 2?
      * @returns boolean
      */
     isOver(): boolean;

package/dist/cjs/src/service/match/match-set.js

@@ -40,7 +40,7 @@ class MatchSet {
         this.rallies.push(rally);
     }
     /**
-     * Has a team reached at least 25 points and is the score difference between both teams at least 2?
+     * Has a team reached at least 25 points, and is the score difference between both teams at least 2?
      * @returns boolean
      */
     isOver() {

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

@@ -4,6 +4,7 @@ import { Country } from '../country';
 import { Rarity } from './rarity';
 import { Stats } from './stats';
 import { Role } from './role';
+import { SetStatistics } from '../match';
 export declare class Stat {
     readonly name: Stats;
     readonly value: number;
@@ -21,6 +22,7 @@ interface PlayerParams {
     readonly roles: Role[];
     readonly traits: Trait[];
     readonly rarity: Rarity;
+    readonly gameStats?: SetStatistics[];
 }
 export declare class Name {
     readonly first: string;
@@ -40,7 +42,8 @@ export declare class Player {
     readonly traits: Trait[];
     readonly generalStats: Stat[];
     readonly rarity: Rarity;
-    constructor({ id, name, country, stats, roles, traits, rarity }: PlayerParams);
+    readonly gameStats?: SetStatistics[];
+    constructor({ id, name, country, stats, roles, traits, rarity, gameStats }: PlayerParams);
     static sortPlayers(roles: Role[]): (p1: Player, p2: Player) => number;
     static compareStats(p1: Player, p2: Player): number;
     toString(): string;

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

@@ -25,7 +25,7 @@ class Name {
 }
 exports.Name = Name;
 class Player {
-    constructor({ id, name, country, stats, roles, traits, rarity }) {
+    constructor({ id, name, country, stats, roles, traits, rarity, gameStats }) {
         (0, utils_1.validateUUID)(id);
         this.id = id;
         this.name = name;
@@ -34,6 +34,7 @@ class Player {
         this.roles = roles;
         this.traits = traits;
         this.rarity = rarity;
+        this.gameStats = gameStats;
         this.generalStats = Object.values(stats_1.StatsEnum).map((stat) => ({
             name: stat,
             value: (0, stats_1.calculateStatScore)(stats, stat)

package/dist/esm/src/data/transformers/events.d.ts

@@ -0,0 +1,8 @@
+import { Block, LiberoReplacement, Reception, Serve, Set, Spike, Substitution } from '../../service';
+export declare function transformToBlock(event: any): Block;
+export declare function transformToLiberoReplacement(event: any): LiberoReplacement;
+export declare function transformToReception(event: any): Reception;
+export declare function transformToServe(event: any): Serve;
+export declare function transformToSet(event: any): Set;
+export declare function transformToSubstitution(event: any): Substitution;
+export declare function transformToSpike(event: any): Spike;

package/dist/esm/src/data/transformers/events.js

@@ -0,0 +1,65 @@
+import { Block, LiberoReplacement, Reception, Serve, Set, Spike, Substitution } from '../../service';
+export function transformToBlock(event) {
+    return new Block({
+        failure: event.failure,
+        type: event.type,
+        playerId: event.playerId,
+        target: event.target,
+        blockers: event.blockers,
+        score: event.score,
+        activeTraits: event.activeTraits
+    });
+}
+export function transformToLiberoReplacement(event) {
+    return new LiberoReplacement({
+        playerId: event.playerId,
+        libero: event.libero,
+        type: event.type
+    });
+}
+export function transformToReception(event) {
+    return new Reception({
+        failure: event.failure,
+        type: event.type,
+        playerId: event.playerId,
+        target: event.target,
+        score: event.score,
+        activeTraits: event.activeTraits
+    });
+}
+export function transformToServe(event) {
+    return new Serve({
+        failure: event.failure,
+        type: event.type,
+        playerId: event.playerId,
+        target: event.target,
+        score: event.score,
+        activeTraits: event.activeTraits
+    });
+}
+export function transformToSet(event) {
+    return new Set({
+        failure: event.failure,
+        type: event.type,
+        playerId: event.playerId,
+        target: event.target,
+        score: event.score,
+        activeTraits: event.activeTraits
+    });
+}
+export function transformToSubstitution(event) {
+    return new Substitution({
+        playerId: event.playerId,
+        playerOut: event.playerIdOut
+    });
+}
+export function transformToSpike(event) {
+    return new Spike({
+        failure: event.failure,
+        type: event.type,
+        playerId: event.playerId,
+        target: event.target,
+        score: event.score,
+        activeTraits: event.activeTraits
+    });
+}

package/dist/esm/src/data/transformers/match-set-stats.d.ts

@@ -1,5 +1,5 @@
 import { MatchSetStatsAttributes, MatchSetStatsModel } from '../models';
 import { SetStatistics } from '../../service';
 declare function transformToAttributes(stats: SetStatistics, setId: string): MatchSetStatsAttributes;
-declare function transformToObject(model: MatchSetStatsModel): SetStatistics;
+declare function transformToObject(model: MatchSetStatsModel, index: number): SetStatistics;
 export { transformToObject as transformToMatchSetStats, transformToAttributes as transformFromMatchSetStats };

package/dist/esm/src/data/transformers/match-set-stats.js

@@ -1,7 +1,6 @@
-import { transformToPlayer } from '.';
 function transformToAttributes(stats, setId) {
     return {
-        player_id: stats.player.id,
+        player_id: stats.playerId,
         match_set_id: setId,
         aces: stats.ace,
         assists: stats.assists,
@@ -22,7 +21,7 @@ function transformToAttributes(stats, setId) {
         kill_blocks: stats.killBlocks
     };
 }
-function transformToObject(model) {
+function transformToObject(model, index) {
     return {
         set: {
             success: model.set_success,
@@ -51,7 +50,9 @@ function transformToObject(model) {
         assists: model.assists,
         ralliesPlayed: model.rallies_played,
         attempts: model.attempts,
-        player: transformToPlayer(model.player)
+        playerId: model.player_id,
+        order: index,
+        setsPlayed: 0
     };
 }
 export { transformToObject as transformToMatchSetStats, transformToAttributes as transformFromMatchSetStats };

package/dist/esm/src/data/transformers/player.d.ts

@@ -1,5 +1,7 @@
 import { PlayerAttributes, PlayerModel } from '../models';
-import { Player } from '../../service';
+import { Player, SetStatistics } from '../../service';
 declare function transformToAttributes(player: Player): PlayerAttributes;
 declare function transformToObject(model: PlayerModel): Player;
+export declare function calculateMatchStats(gameStats: SetStatistics[]): SetStatistics;
+export declare function reduceStatsFn(acc: SetStatistics, current: SetStatistics): SetStatistics;
 export { transformToObject as transformToPlayer, transformToAttributes as transformFromPlayer };

package/dist/esm/src/data/transformers/player.js

@@ -1,5 +1,5 @@
 import { Player } from '../../service';
-import { transformFromPerformanceStats, transformToCountry, transformToPerformanceStats } from '.';
+import { transformFromPerformanceStats, transformToCountry, transformToMatchSetStats, transformToPerformanceStats } from '.';
 function transformToAttributes(player) {
     return {
         player_id: player.id,
@@ -13,6 +13,10 @@ function transformToAttributes(player) {
     };
 }
 function transformToObject(model) {
+    const gameStats = (model.MatchSetStats ?? []).map(transformToMatchSetStats);
+    if (gameStats.length > 0) {
+        gameStats.push(calculateMatchStats(gameStats));
+    }
     return new Player({
         id: model.player_id,
         name: {
@@ -23,7 +27,49 @@ function transformToObject(model) {
         roles: model.roles,
         traits: model.traits,
         stats: transformToPerformanceStats(model.PerformanceStat),
-        rarity: model.rarity
+        rarity: model.rarity,
+        gameStats
     });
 }
+export function calculateMatchStats(gameStats) {
+    const emptyStats = {
+        playerId: gameStats[0].playerId,
+        attempts: 0,
+        contacts: 0,
+        ralliesPlayed: 0,
+        serve: { success: 0, error: 0 },
+        reception: { success: 0, error: 0 },
+        set: { success: 0, error: 0 },
+        attack: { success: 0, error: 0 },
+        block: { success: 0, error: 0 },
+        kills: 0,
+        killBlocks: 0,
+        ace: 0,
+        assists: 0,
+        order: gameStats.length,
+        setsPlayed: 0
+    };
+    return gameStats.reduce(reduceStatsFn, emptyStats);
+}
+export function reduceStatsFn(acc, current) {
+    acc.attempts += current.attempts;
+    acc.contacts += current.contacts;
+    acc.ralliesPlayed += current.ralliesPlayed;
+    acc.kills += current.kills;
+    acc.killBlocks += current.killBlocks;
+    acc.ace += current.ace;
+    acc.assists += current.assists;
+    acc.serve.success += current.serve.success;
+    acc.serve.error += current.serve.error;
+    acc.reception.success += current.reception.success;
+    acc.reception.error += current.reception.error;
+    acc.set.success += current.set.success;
+    acc.set.error += current.set.error;
+    acc.attack.success += current.attack.success;
+    acc.attack.error += current.attack.error;
+    acc.block.success += current.block.success;
+    acc.block.error += current.block.error;
+    acc.setsPlayed++;
+    return acc;
+}
 export { transformToObject as transformToPlayer, transformToAttributes as transformFromPlayer };

package/dist/esm/src/data/transformers/rally.js

@@ -1,6 +1,7 @@
 import { Rally } from '../../service';
 import { compressToBase64, decompressFromBase64 } from 'lz-string';
 import { transformToTeam } from './team';
+import { transformToBlock, transformToLiberoReplacement, transformToReception, transformToServe, transformToSet, transformToSpike, transformToSubstitution } from './events';
 function transformToAttributes(rally, setId) {
     const events = `[${rally.events.map((e) => e.toString()).join(',')}]`;
     return {
@@ -12,7 +13,36 @@ function transformToAttributes(rally, setId) {
     };
 }
 function transformToObject(model) {
-    const events = JSON.parse(decompressFromBase64(model.events));
+    const decompressed = decompressFromBase64(model.events);
+    const parsed = JSON.parse(decompressed);
+    const events = [];
+    parsed.forEach(event => {
+        switch (event.eventType) {
+            case 0:
+                events.push(transformToLiberoReplacement(event));
+                break;
+            case 1:
+                events.push(transformToSubstitution(event));
+                break;
+            case 2:
+                events.push(transformToServe(event));
+                break;
+            case 3:
+                events.push(transformToReception(event));
+                break;
+            case 4:
+                events.push(transformToSet(event));
+                break;
+            case 5:
+                events.push(transformToSpike(event));
+                break;
+            case 6:
+                events.push(transformToBlock(event));
+                break;
+            default:
+                throw new Error('UNKNOWN_EVENT');
+        }
+    });
     return new Rally({
         id: model.rally_id,
         order: model.order,

package/dist/esm/src/data/transformers/team.d.ts

@@ -1,5 +1,5 @@
 import { Team } from '../../service';
 import { TeamAttributes, TeamModel } from '../models';
 declare function transformToAttributes(team: Team): TeamAttributes;
-declare function transformToObject(team: TeamModel): Team;
+declare function transformToObject(model: TeamModel): Team;
 export { transformToObject as transformToTeam, transformToAttributes as transformFromTeam };

package/dist/esm/src/data/transformers/team.js

@@ -1,5 +1,5 @@
 import { Team } from '../../service';
-import { transformFromCoach, transformToCoach, transformToCountry, transformToPlayer } from '.';
+import { transformFromCoach, transformToCoach, transformToCountry, transformToLeague, transformToPlayer } from '.';
 function transformToAttributes(team) {
     return {
         team_id: team.id,
@@ -12,15 +12,16 @@ function transformToAttributes(team) {
         rating: team.rating
     };
 }
-function transformToObject(team) {
+function transformToObject(model) {
     return new Team({
-        id: team.team_id,
-        name: team.name,
-        shortName: team.short_name,
-        country: team.country != null ? transformToCountry(team.country) : undefined,
-        coach: team.coach != null ? transformToCoach(team.coach) : undefined,
-        roster: (team.PlayerTeams ?? []).map((pt) => transformToPlayer(pt.player)),
-        rating: team.rating
+        id: model.team_id,
+        name: model.name,
+        shortName: model.short_name,
+        country: model.country != null ? transformToCountry(model.country) : undefined,
+        coach: model.coach != null ? transformToCoach(model.coach) : undefined,
+        roster: (model.PlayerTeams ?? []).map((pt) => transformToPlayer(pt.player)),
+        league: model.league != null ? transformToLeague(model.league) : undefined,
+        rating: model.rating
     });
 }
 export { transformToObject as transformToTeam, transformToAttributes as transformFromTeam };

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

@@ -0,0 +1,36 @@
+import { InPlayEvent } from './in-play-event';
+import { CourtTarget } from '../match';
+import { Trait } from '../player';
+export declare enum BlockFailureEnum {
+    NO_FAILURE = 0,
+    MISS = 1,
+    FAULT = 2,
+    OUT_OF_BOUNDS = 3,
+    WIPE = 4,
+    TOOL = 5
+}
+export type BlockFailure = BlockFailureEnum.NO_FAILURE | BlockFailureEnum.MISS | BlockFailureEnum.FAULT | BlockFailureEnum.OUT_OF_BOUNDS | BlockFailureEnum.WIPE | BlockFailureEnum.TOOL;
+export declare enum BlockTypeEnum {
+    NO_BLOCKER = 0,
+    SINGLE = 1,
+    DOUBLE = 2,
+    TRIPLE = 3
+}
+export type BlockType = BlockTypeEnum.NO_BLOCKER | BlockTypeEnum.SINGLE | BlockTypeEnum.DOUBLE | BlockTypeEnum.TRIPLE;
+interface BlockOpts {
+    readonly type: BlockType;
+    readonly failure: BlockFailure;
+    readonly blockers: string[];
+    readonly target: CourtTarget;
+    readonly score: number;
+    readonly activeTraits: Trait[];
+    readonly playerId: string;
+}
+export declare class Block extends InPlayEvent<BlockFailure, BlockType> {
+    readonly failure: BlockFailure;
+    readonly type: BlockType;
+    readonly blockers: string[];
+    constructor({ score, playerId, target, failure, type, blockers, activeTraits }: BlockOpts);
+    toString(): string;
+}
+export {};

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

@@ -0,0 +1,33 @@
+import { InPlayEvent } from './in-play-event';
+import { EventTypeEnum } from './rally-event';
+export var BlockFailureEnum;
+(function (BlockFailureEnum) {
+    BlockFailureEnum[BlockFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
+    BlockFailureEnum[BlockFailureEnum["MISS"] = 1] = "MISS";
+    BlockFailureEnum[BlockFailureEnum["FAULT"] = 2] = "FAULT";
+    BlockFailureEnum[BlockFailureEnum["OUT_OF_BOUNDS"] = 3] = "OUT_OF_BOUNDS";
+    BlockFailureEnum[BlockFailureEnum["WIPE"] = 4] = "WIPE";
+    BlockFailureEnum[BlockFailureEnum["TOOL"] = 5] = "TOOL";
+})(BlockFailureEnum || (BlockFailureEnum = {}));
+export var BlockTypeEnum;
+(function (BlockTypeEnum) {
+    BlockTypeEnum[BlockTypeEnum["NO_BLOCKER"] = 0] = "NO_BLOCKER";
+    BlockTypeEnum[BlockTypeEnum["SINGLE"] = 1] = "SINGLE";
+    BlockTypeEnum[BlockTypeEnum["DOUBLE"] = 2] = "DOUBLE";
+    BlockTypeEnum[BlockTypeEnum["TRIPLE"] = 3] = "TRIPLE";
+})(BlockTypeEnum || (BlockTypeEnum = {}));
+const eventType = EventTypeEnum.BLOCK;
+export class Block extends InPlayEvent {
+    constructor({ score, playerId, target, failure, type, blockers, activeTraits }) {
+        super({ score, playerId, target, activeTraits, eventType });
+        this.type = type;
+        this.failure = failure;
+        this.blockers = blockers;
+    }
+    toString() {
+        const failure = `"failure":${this.failure}`;
+        const type = `"type":${this.type}`;
+        const blockers = `"blockers":[${this.blockers.map(b => `"${b}"`).join(',')}]`;
+        return `{${this._toString()},${failure},${type},${blockers}}`;
+    }
+}

package/dist/esm/src/service/event/in-play-event.d.ts

@@ -0,0 +1,17 @@
+import { CourtTarget } from '../match';
+import { RallyEvent, RallyEventOpts } from './rally-event';
+import { Trait } from '../player';
+export interface InPlayEventOpts extends RallyEventOpts {
+    readonly target: CourtTarget;
+    readonly score: number;
+    readonly activeTraits: Trait[];
+}
+export declare abstract class InPlayEvent<F, T> extends RallyEvent {
+    abstract failure: F;
+    abstract type: T;
+    readonly target: CourtTarget;
+    readonly score: number;
+    readonly activeTraits: Trait[];
+    protected constructor({ eventType, playerId, target, score, activeTraits }: InPlayEventOpts);
+    protected _toString(): string;
+}