volleyballsimtypes 0.0.122 → 0.0.124

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

@@ -1,80 +1,11 @@
-import { Spike, SpikeFailureEnum, SpikeTypeEnum } from '../../service';
-import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer } from '.';
-function transformToSpikeFailure(failure) {
-    switch (failure) {
-        case SpikeFailureEnum.NO_FAILURE:
-            return 'NO_FAILURE';
-        case SpikeFailureEnum.FAULT:
-            return 'FAULT';
-        case SpikeFailureEnum.MISS:
-            return 'MISS';
-        case SpikeFailureEnum.OUT_OF_BOUNDS:
-            return 'OUT_OF_BOUNDS';
-        case SpikeFailureEnum.NET:
-            return 'NET';
-        default:
-            throw new Error('UNKNOWN_ROLE');
-    }
-}
-function transformFromSpikeFailure(failure) {
-    return SpikeFailureEnum[failure];
-}
-function transformToSpikeType(type) {
-    switch (type) {
-        case SpikeTypeEnum.CROSS_SHOT:
-            return 'CROSS_SHOT';
-        case SpikeTypeEnum.LINE_SHOT:
-            return 'LINE_SHOT';
-        case SpikeTypeEnum.TOOL_SHOT:
-            return 'TOOL_SHOT';
-        case SpikeTypeEnum.TIP:
-            return 'TIP';
-        case SpikeTypeEnum.DOWN_BALL:
-            return 'DOWN_BALL';
-        case SpikeTypeEnum.OVERHAND:
-            return 'OVERHAND';
-        default:
-            throw new Error('UNKNOWN_ROLE');
-    }
-}
-function transformFromSpikeType(type) {
-    return SpikeTypeEnum[type];
-}
-function transformToAttributes(event, rallyId) {
-    return {
-        event_id: event.id,
-        player_id: event.player.id,
-        rally_id: rallyId,
-        order: event.order,
-        target: transformFromCourtTarget(event.target),
-        failure: transformToSpikeFailure(event.failure),
-        type: transformToSpikeType(event.type),
-        event_type: transformFromEventType(event.eventType)
-    };
-}
-function transformToObject(spike) {
-    return new Spike({
-        id: spike.event_id,
-        eventType: transformToEventType(spike.event_type),
-        failure: transformFromSpikeFailure(spike.failure),
-        type: transformFromSpikeType(spike.type),
-        player: transformToPlayer(spike.player),
-        target: transformToCourtTarget(spike.target),
-        order: spike.order,
-        modifier: 1,
-        score: 1,
-        activeTraits: []
-    });
-}
 function transformToAPIObject(event) {
     return {
-        id: event.event_id,
-        eventType: transformToEventType(event.event_type),
-        failure: transformFromSpikeFailure(event.failure),
-        type: transformFromSpikeType(event.type),
-        playerId: event.player_id,
-        target: transformToCourtTarget(event.target),
-        order: event.order,
+        eventType: event.eventType,
+        failure: event.failure,
+        type: event.type,
+        playerId: event.player,
+        target: event.target,
+        order: event.order
     };
 }
-export { transformToObject as transformToSpike, transformToAPIObject as transformToAPISpike, transformToAttributes as transformFromSpike };
+export { transformToAPIObject as transformToAPISpike };

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

@@ -1,7 +1,3 @@
-import { Substitution } from '../../service';
-import { SubstitutionAttributes, SubstitutionModel } from '../models';
 import { APISubstitution } from '../../api';
-declare function transformToAttributes(event: Substitution, rallyId: string): SubstitutionAttributes;
-declare function transformToObject(event: SubstitutionModel): Substitution;
-declare function transformToAPIObject(event: SubstitutionModel): APISubstitution;
-export { transformToObject as transformToSubstitution, transformToAPIObject as transformToAPISubstitution, transformToAttributes as transformFromSubstitution };
+declare function transformToAPIObject(event: any): APISubstitution;
+export { transformToAPIObject as transformToAPISubstitution };

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

@@ -1,31 +1,9 @@
-import { Substitution } from '../../service';
-import { transformFromEventType, transformToEventType, transformToPlayer } from '.';
-function transformToAttributes(event, rallyId) {
-    return {
-        player_id: event.player.id,
-        event_id: event.id,
-        order: event.order,
-        event_type: transformFromEventType(event.eventType),
-        player_out: event.playerOut.id,
-        rally_id: rallyId
-    };
-}
-function transformToObject(event) {
-    return new Substitution({
-        id: event.event_id,
-        player: transformToPlayer(event.player),
-        playerOut: transformToPlayer(event.playerOut),
-        order: event.order,
-        eventType: transformToEventType(event.event_type)
-    });
-}
 function transformToAPIObject(event) {
     return {
-        id: event.event_id,
-        eventType: transformToEventType(event.event_type),
-        playerId: event.player_id,
+        eventType: event.eventType,
+        playerId: event.player,
         order: event.order,
-        playerOutId: event.player_out
+        playerOutId: event.playerOut
     };
 }
-export { transformToObject as transformToSubstitution, transformToAPIObject as transformToAPISubstitution, transformToAttributes as transformFromSubstitution };
+export { transformToAPIObject as transformToAPISubstitution };

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

@@ -1,5 +1,5 @@
 import { Team } from '../../service';
-import { transformFromCoach, transformToAPICoach, transformToAPIPlayer, transformToCoach, transformToCountry, transformToPlayer } from '.';
+import { transformFromCoach, transformToAPICoach, transformToAPIPlayer, transformToCoach, transformToCountry, transformToLeague, transformToPlayer } from '.';
 function transformToAttributes(team) {
     return {
         team_id: team.id,
@@ -17,9 +17,10 @@ function transformToObject(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 != null ? team.PlayerTeams.map(pt => transformToPlayer(pt.player)) : [],
+        country: transformToCountry(team.country),
+        coach: transformToCoach(team.coach),
+        roster: team.PlayerTeams.map(pt => transformToPlayer(pt.player)),
+        league: transformToLeague(team.league),
         rating: team.rating
     });
 }

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

@@ -6,10 +6,12 @@ function transformToAttributes(tournament) {
         competition_id: tournament.id,
         team_id: team.id
     }));
-    const champion = tournament.champion != null ? {
-        competition_id: tournament.id,
-        team_id: tournament.champion?.id
-    } : undefined;
+    const champion = tournament.champion != null
+        ? {
+            competition_id: tournament.id,
+            team_id: tournament.champion?.id
+        }
+        : undefined;
     return {
         competition_id: tournament.id,
         type: 'TOURNAMENT',

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

@@ -27,6 +27,10 @@ function transformToAPIObject(model) {
     }
 }
 function transformToObject(model) {
-    return Trait.getTraits().find(trait => trait.id === model.trait_id);
+    const trait = Trait.getTraits().find(trait => trait.id === model.trait_id);
+    if (trait == null) {
+        throw new Error('TRAIT_NOT_FOUND');
+    }
+    return trait;
 }
 export { transformToObject as transformToTrait, transformToAPIObject as transformToAPITrait, transformToAttributes as transformFromTrait };

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

@@ -6,14 +6,14 @@ interface CoachOpts {
     readonly name: Name;
     readonly country: Country;
     readonly formation: Formation;
-    readonly substitutionTolerance?: number;
+    readonly substitutionTolerance: number;
 }
 export declare class Coach {
     readonly id: string;
     readonly name: Name;
     readonly country: Country;
     readonly formation: Formation;
-    readonly substitutionTolerance?: number;
+    readonly substitutionTolerance: number;
     constructor({ id, name, country, formation, substitutionTolerance }: CoachOpts);
 }
 export {};

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

@@ -22,8 +22,9 @@ interface BlockOpts extends InPlayEventOpts {
 export declare class Block extends InPlayEvent {
     readonly failure: BlockFailureEnum;
     readonly type: BlockTypeEnum;
-    readonly blockers: Player[];
-    constructor({ id, order, score, player, target, failure, type, modifier, eventType, blockers, activeTraits }: BlockOpts);
+    readonly blockers: string[];
+    constructor({ order, score, player, target, failure, type, modifier, eventType, blockers, activeTraits }: BlockOpts);
     static getScore(blockers: Player[], modifier: number, activeTraits: Trait[]): number;
+    toString(): string;
 }
 export {};

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

@@ -17,11 +17,11 @@ export var BlockTypeEnum;
     BlockTypeEnum[BlockTypeEnum["TRIPLE"] = 3] = "TRIPLE";
 })(BlockTypeEnum || (BlockTypeEnum = {}));
 export class Block extends InPlayEvent {
-    constructor({ id, order, score, player, target, failure, type, modifier, eventType, blockers, activeTraits }) {
-        super({ id, order, score, player, target, modifier, eventType, activeTraits });
+    constructor({ order, score, player, target, failure, type, modifier, eventType, blockers, activeTraits }) {
+        super({ order, score, player, target, modifier, eventType, activeTraits });
         this.type = type;
         this.failure = failure;
-        this.blockers = blockers;
+        this.blockers = blockers.map(b => b.id);
     }
     static getScore(blockers, modifier, activeTraits) {
         const type = blockers.length;
@@ -58,4 +58,7 @@ export class Block extends InPlayEvent {
         }
         return score;
     }
+    toString() {
+        return `{order:${this.order},score:${this.order},player:${this.player},target:${this.target},failure:${this.failure},type:${this.type},modifier:${this.modifier},eventType:${this.eventType},blockers:[${this.blockers.join(',')}],activeTraits:[${this.activeTraits.join(',')}]}`;
+    }
 }

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

@@ -13,7 +13,7 @@ export declare abstract class InPlayEvent extends RallyEvent {
     readonly target: CourtTargetEnum;
     readonly modifier: number;
     readonly score: number;
-    readonly activeTraits: Trait[];
-    protected constructor({ id, eventType, player, target, modifier, score, order, activeTraits }: InPlayEventOpts);
+    readonly activeTraits: string[];
+    protected constructor({ eventType, player, target, modifier, score, order, activeTraits }: InPlayEventOpts);
     protected static calculateScore(stats: PerformanceStats, eventType: string, type: string): number;
 }

package/dist/esm/src/service/event/in-play-event.js

@@ -2,12 +2,12 @@ import { RallyEvent } from './rally-event';
 import formula from '../../../data/event.formula.json';
 import { getKeys } from '../utils';
 export class InPlayEvent extends RallyEvent {
-    constructor({ id, eventType, player, target, modifier, score, order, activeTraits }) {
-        super({ id, order, player, eventType });
+    constructor({ eventType, player, target, modifier, score, order, activeTraits }) {
+        super({ order, player, eventType });
         this.target = target;
         this.score = score;
         this.modifier = modifier;
-        this.activeTraits = activeTraits;
+        this.activeTraits = activeTraits.map(trait => trait.id);
     }
     static calculateScore(stats, eventType, type) {
         const weight = formula[eventType][type];

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

@@ -11,7 +11,8 @@ export declare enum LiberoReplacementTypeEnum {
 }
 export declare class LiberoReplacement extends RallyEvent {
     readonly type: LiberoReplacementTypeEnum;
-    readonly libero: Player;
-    constructor({ id, order, player, type, libero, eventType }: LiberoReplacementOpts);
+    readonly libero: string;
+    constructor({ order, player, type, libero, eventType }: LiberoReplacementOpts);
+    toString(): string;
 }
 export {};

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

@@ -5,9 +5,12 @@ export var LiberoReplacementTypeEnum;
     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 });
+    constructor({ order, player, type, libero, eventType }) {
+        super({ order, player, eventType });
         this.type = type;
-        this.libero = libero;
+        this.libero = libero.id;
+    }
+    toString() {
+        return `{order:${this.order},player:${this.player},type:${this.type},eventType:${this.eventType},libero:${this.libero}}`;
     }
 }

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

@@ -9,15 +9,13 @@ export declare enum EventTypeEnum {
     BLOCK = 6
 }
 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 player: string;
     readonly eventType: EventTypeEnum;
-    protected constructor({ id, eventType, player, order }: RallyEventOpts);
+    protected constructor({ eventType, player, order }: RallyEventOpts);
 }

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

@@ -9,9 +9,8 @@ export var EventTypeEnum;
     EventTypeEnum[EventTypeEnum["BLOCK"] = 6] = "BLOCK";
 })(EventTypeEnum || (EventTypeEnum = {}));
 export class RallyEvent {
-    constructor({ id, eventType, player, order }) {
-        this.id = id;
-        this.player = player;
+    constructor({ eventType, player, order }) {
+        this.player = player.id;
         this.order = order;
         this.eventType = eventType;
     }

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

@@ -20,7 +20,8 @@ interface ReceptionOpts extends InPlayEventOpts {
 export declare class Reception extends InPlayEvent {
     readonly failure: ReceptionFailureEnum;
     readonly type: ReceptionTypeEnum;
-    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }: ReceptionOpts);
+    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }: ReceptionOpts);
     static getScore(stats: PerformanceStats, type: ReceptionTypeEnum, modifier: number, activeTraits: Trait[]): number;
+    toString(): string;
 }
 export {};

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

@@ -16,8 +16,8 @@ export var ReceptionFailureEnum;
     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 });
+    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ order, score, player, target, eventType, modifier, activeTraits });
         this.type = type;
         this.failure = failure;
     }
@@ -33,4 +33,7 @@ export class Reception extends InPlayEvent {
         }
         return score;
     }
+    toString() {
+        return `{order:${this.order},score:${this.order},player:${this.player},target:${this.target},failure:${this.failure},type:${this.type},modifier:${this.modifier},eventType:${this.eventType},activeTraits:[${this.activeTraits.join(',')}]}`;
+    }
 }

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

@@ -21,7 +21,8 @@ interface ServeOpts extends InPlayEventOpts {
 export declare class Serve extends InPlayEvent {
     readonly failure: ServeFailureEnum;
     readonly type: ServeTypeEnum;
-    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }: ServeOpts);
+    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }: ServeOpts);
     static getScore(stats: PerformanceStats, type: ServeTypeEnum, modifier: number, activeTraits: Trait[]): number;
+    toString(): string;
 }
 export {};

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

@@ -1,5 +1,4 @@
 import { InPlayEvent } from './in-play-event';
-import { Trait } from '../player';
 export var ServeTypeEnum;
 (function (ServeTypeEnum) {
     ServeTypeEnum[ServeTypeEnum["UNDERHAND"] = 0] = "UNDERHAND";
@@ -17,21 +16,19 @@ export var ServeFailureEnum;
     ServeFailureEnum[ServeFailureEnum["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
 })(ServeFailureEnum || (ServeFailureEnum = {}));
 export class Serve extends InPlayEvent {
-    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
-        super({ id, order, score, player, target, eventType, modifier, activeTraits });
+    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ order, score, player, target, eventType, modifier, activeTraits });
         this.type = type;
         this.failure = failure;
     }
     static getScore(stats, type, modifier, activeTraits) {
         let score = Serve.calculateScore(stats, 'SERVE', ServeTypeEnum[type]) * modifier;
         for (const trait of activeTraits) {
-            switch (true) {
-                case trait === Trait.METEOR_SERVE: {
-                    score *= Trait.METEOR_SERVE.modifier;
-                    break;
-                }
-            }
+            score *= trait.modifier;
         }
         return score;
     }
+    toString() {
+        return `{order:${this.order},score:${this.order},player:${this.player},target:${this.target},failure:${this.failure},type:${this.type},modifier:${this.modifier},eventType:${this.eventType},activeTraits:[${this.activeTraits.join(',')}]}`;
+    }
 }

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

@@ -20,7 +20,8 @@ interface SetOpts extends InPlayEventOpts {
 export declare class Set extends InPlayEvent {
     readonly failure: SetFailureEnum;
     readonly type: SetTypeEnum;
-    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }: SetOpts);
+    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }: SetOpts);
     static getScore(stats: PerformanceStats, type: SetTypeEnum, modifier: number, activeTraits: Trait[]): number;
+    toString(): string;
 }
 export {};

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

@@ -16,8 +16,8 @@ export var SetFailureEnum;
     SetFailureEnum[SetFailureEnum["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
 })(SetFailureEnum || (SetFailureEnum = {}));
 export class Set extends InPlayEvent {
-    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
-        super({ id, order, score, player, target, eventType, modifier, activeTraits });
+    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ order, score, player, target, eventType, modifier, activeTraits });
         this.type = type;
         this.failure = failure;
     }
@@ -38,4 +38,7 @@ export class Set extends InPlayEvent {
         }
         return score;
     }
+    toString() {
+        return `{order:${this.order},score:${this.order},player:${this.player},target:${this.target},failure:${this.failure},type:${this.type},modifier:${this.modifier},eventType:${this.eventType},activeTraits:[${this.activeTraits.join(',')}]}`;
+    }
 }

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

@@ -22,7 +22,8 @@ interface SpikeOpts extends InPlayEventOpts {
 export declare class Spike extends InPlayEvent {
     readonly failure: SpikeFailureEnum;
     readonly type: SpikeTypeEnum;
-    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }: SpikeOpts);
+    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }: SpikeOpts);
     static getScore(player: Player, type: SpikeTypeEnum, modifier: number, isBackRow: boolean, activeTraits: Trait[]): number;
+    toString(): string;
 }
 export {};

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

@@ -18,8 +18,8 @@ export var SpikeFailureEnum;
     SpikeFailureEnum[SpikeFailureEnum["NET"] = 4] = "NET";
 })(SpikeFailureEnum || (SpikeFailureEnum = {}));
 export class Spike extends InPlayEvent {
-    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
-        super({ id, order, score, player, target, eventType, modifier, activeTraits });
+    constructor({ order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ order, score, player, target, eventType, modifier, activeTraits });
         this.type = type;
         this.failure = failure;
     }
@@ -43,4 +43,7 @@ export class Spike extends InPlayEvent {
         }
         return score;
     }
+    toString() {
+        return `{order:${this.order},score:${this.order},player:${this.player},target:${this.target},failure:${this.failure},type:${this.type},modifier:${this.modifier},eventType:${this.eventType},activeTraits:[${this.activeTraits.join(',')}]}`;
+    }
 }

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

@@ -4,7 +4,8 @@ interface SubstitutionOpts extends RallyEventOpts {
     readonly playerOut: Player;
 }
 export declare class Substitution extends RallyEvent {
-    readonly playerOut: Player;
-    constructor({ id, order, playerOut, player, eventType }: SubstitutionOpts);
+    readonly playerOut: string;
+    constructor({ order, playerOut, player, eventType }: SubstitutionOpts);
+    toString(): string;
 }
 export {};

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

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

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

@@ -8,18 +8,18 @@ interface TeamOpts {
     readonly name: string;
     readonly shortName: string;
     readonly roster: Player[];
-    readonly country?: Country;
-    readonly league?: League;
-    readonly coach?: Coach;
+    readonly country: Country;
+    readonly league: League;
+    readonly coach: Coach;
 }
 export declare class Team {
     readonly id: string;
     readonly roster: Player[];
     readonly name: string;
     readonly shortName: string;
-    readonly coach?: Coach;
-    readonly league?: League;
-    readonly country?: Country;
+    readonly coach: Coach;
+    readonly league: League;
+    readonly country: Country;
     private _rating;
     constructor({ id, rating, name, shortName, country, roster, coach, league }: TeamOpts);
     get rating(): number;

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

@@ -22,6 +22,9 @@ export class Team {
         return this.roster.some(p => p.id === player.id);
     }
     toString() {
+        if (this.country == null) {
+            throw new Error('UNKNOWN_COUNTRY');
+        }
         return `${this.name} [${this.shortName}] (${this.country?.name}) ELO=${this._rating}`;
     }
     updateRating(ratingChange) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "volleyballsimtypes",
-  "version": "0.0.122",
+  "version": "0.0.124",
   "description": "vbsim types",
   "main": "./dist/cjs/src/index.js",
   "module": "./dist/esm/src/index.js",
@@ -11,9 +11,9 @@
     "madge": "npx madge --warning --circular --extensions ts ./",
     "standard": "npx ts-standard --fix",
     "clean": "rimraf dist",
-    "prebuild": "npm run clean",
+    "validate": "npm run standard && npm run madge",
     "build": "tsc -p tsconfig.json && tsc -p tsconfig-cjs.json",
-    "preversion": "npm run build",
+    "preversion": "npm run validate && npm run build",
     "postversion": "git push --follow-tags"
   },
   "author": "Francisco Farias <fariasfranciscoe@gmail.com>",
@@ -33,6 +33,7 @@
   },
   "dependencies": {
     "@types/sequelize": "^4.28.15",
+    "lz-string": "^1.5.0",
     "moment": "^2.29.4",
     "pg": "^8.11.1",
     "pg-hstore": "^2.3.4",

package/dist/cjs/src/data/models/block.d.ts

@@ -1,56 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { Model, Optional } from 'sequelize';
-import { CourtTarget, EventType, PlayerId, PlayerModel, RallyId, RallyModel } from '.';
-export interface BlockAttributes {
-    event_id: string;
-    rally_id: string;
-    order: number;
-    player_id: string;
-    target: CourtTarget;
-    type: BlockType;
-    failure: BlockFailure;
-    blocker_1?: string;
-    blocker_2?: string;
-    blocker_3?: string;
-    event_type: EventType;
-}
-export type BlockPk = 'event_id';
-export type BlockType = 'NO_BLOCKER' | 'SINGLE' | 'DOUBLE' | 'TRIPLE';
-export type BlockFailure = 'NO_FAILURE' | 'FAULT' | 'MISS' | 'OUT_OF_BOUNDS' | 'WIPE' | 'TOOL';
-export type BlockId = BlockModel[BlockPk];
-export type BlockOptionalAttributes = 'blocker_1' | 'blocker_2' | 'blocker_3';
-export type BlockCreationAttributes = Optional<BlockAttributes, BlockOptionalAttributes>;
-export declare class BlockModel extends Model<BlockAttributes, BlockCreationAttributes> implements BlockAttributes {
-    event_id: string;
-    rally_id: string;
-    order: number;
-    player_id: string;
-    target: CourtTarget;
-    type: BlockType;
-    failure: BlockFailure;
-    blocker_1?: string;
-    blocker_2?: string;
-    blocker_3?: string;
-    event_type: EventType;
-    player: PlayerModel;
-    getPlayer: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
-    setPlayer: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
-    createPlayer: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>;
-    Blocker_1: PlayerModel;
-    getBlocker_1: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
-    setBlocker_1: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
-    createBlocker_1: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>;
-    Blocker_2: PlayerModel;
-    getBlocker_2: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
-    setBlocker_2: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
-    createBlocker_2: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>;
-    Blocker_3: PlayerModel;
-    getBlocker_3: Sequelize.BelongsToGetAssociationMixin<PlayerModel>;
-    setBlocker_3: Sequelize.BelongsToSetAssociationMixin<PlayerModel, PlayerId>;
-    createBlocker_3: Sequelize.BelongsToCreateAssociationMixin<PlayerModel>;
-    rally: RallyModel;
-    getRally: Sequelize.BelongsToGetAssociationMixin<RallyModel>;
-    setRally: Sequelize.BelongsToSetAssociationMixin<RallyModel, RallyId>;
-    createRally: Sequelize.BelongsToCreateAssociationMixin<RallyModel>;
-    static initModel(sequelize: Sequelize.Sequelize): typeof BlockModel;
-}