volleyballsimtypes 0.0.122 → 0.0.123

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

@@ -1,37 +1,52 @@
-import { EventTypeEnum, Rally } from '../../service';
-import { transformFromBlock, transformFromLiberoReplacement, transformFromReception, transformFromServe, transformFromSet, transformFromSpike, transformFromSubstitution, transformToAPIBlock, transformToAPILiberoReplacement, transformToAPIReception, transformToAPIServe, transformToAPISet, transformToAPISpike, transformToAPISubstitution, transformToBlock, transformToLiberoReplacement, transformToReception, transformToServe, transformToSet, transformToSpike, transformToSubstitution, transformToTeam } from '.';
+import { Rally } from '../../service';
+import { transformToAPIBlock, transformToAPILiberoReplacement, transformToAPIReception, transformToAPIServe, transformToAPISet, transformToAPISpike, transformToAPISubstitution, transformToTeam } from '.';
+import { compressToBase64, decompressFromBase64 } from 'lz-string';
 function transformToAttributes(rally, setId) {
+    const events = `[${rally.events.map(e => e.toString()).join(',')}]`;
     return {
         rally_id: rally.id,
         match_set_id: setId,
         order: rally.order,
         serving_team: rally.servingTeam.id,
-        LiberoReplacements: rally.events.filter(event => event.eventType === EventTypeEnum.LIBERO_REPLACEMENT)
-            .map(event => transformFromLiberoReplacement(event, rally.id)),
-        Substitutions: rally.events.filter(event => event.eventType === EventTypeEnum.SUBSTITUTION)
-            .map(event => transformFromSubstitution(event, rally.id)),
-        Serves: rally.events.filter(event => event.eventType === EventTypeEnum.SERVE)
-            .map(event => transformFromServe(event, rally.id)),
-        Receptions: rally.events.filter(event => event.eventType === EventTypeEnum.RECEPTION)
-            .map(event => transformFromReception(event, rally.id)),
-        Sets: rally.events.filter(event => event.eventType === EventTypeEnum.SET)
-            .map(event => transformFromSet(event, rally.id)),
-        Spikes: rally.events.filter(event => event.eventType === EventTypeEnum.SPIKE)
-            .map(event => transformFromSpike(event, rally.id)),
-        Blocks: rally.events.filter(event => event.eventType === EventTypeEnum.BLOCK)
-            .map(event => transformFromBlock(event, rally.id))
+        events: compressToBase64(events)
     };
 }
 function transformToObject(model) {
-    const liberoReplacements = model.LiberoReplacements != null ?
-        model.LiberoReplacements.map(transformToLiberoReplacement) : [];
-    const substitutions = model.Substitutions != null ?
-        model.Substitutions.map(transformToSubstitution) : [];
-    const serves = model.Serves != null ? model.Serves.map(transformToServe) : [];
-    const receptions = model.Receptions != null ? model.Receptions.map(transformToReception) : [];
-    const sets = model.Sets != null ? model.Sets.map(transformToSet) : [];
-    const spikes = model.Spikes != null ? model.Spikes.map(transformToSpike) : [];
-    const blocks = model.Blocks != null ? model.Blocks.map(transformToBlock) : [];
+    const decompressed = JSON.parse(decompressFromBase64(model.events));
+    const liberoReplacements = [];
+    const substitutions = [];
+    const serves = [];
+    const receptions = [];
+    const sets = [];
+    const spikes = [];
+    const blocks = [];
+    decompressed.forEach(event => {
+        switch (event.event_type) {
+            case 0:
+                liberoReplacements.push(event);
+                break;
+            case 1:
+                substitutions.push(event);
+                break;
+            case 2:
+                serves.push(event);
+                break;
+            case 3:
+                receptions.push(event);
+                break;
+            case 4:
+                sets.push(event);
+                break;
+            case 5:
+                spikes.push(event);
+                break;
+            case 6:
+                blocks.push(event);
+                break;
+            default:
+                throw new Error('UNKNOWN_EVENT');
+        }
+    });
     const events = [...liberoReplacements, ...substitutions, ...serves, ...receptions, ...sets, ...spikes, ...blocks]
         .sort((e1, e2) => e1.order - e2.order);
     return new Rally({
@@ -42,15 +57,41 @@ function transformToObject(model) {
     });
 }
 function transformToAPIObject(model) {
-    const liberoReplacements = model.LiberoReplacements != null ?
-        model.LiberoReplacements.map(transformToAPILiberoReplacement) : [];
-    const substitutions = model.Substitutions != null ?
-        model.Substitutions.map(transformToAPISubstitution) : [];
-    const serves = model.Serves != null ? model.Serves.map(transformToAPIServe) : [];
-    const receptions = model.Receptions != null ? model.Receptions.map(transformToAPIReception) : [];
-    const sets = model.Sets != null ? model.Sets.map(transformToAPISet) : [];
-    const spikes = model.Spikes != null ? model.Spikes.map(transformToAPISpike) : [];
-    const blocks = model.Blocks != null ? model.Blocks.map(transformToAPIBlock) : [];
+    const decompressed = JSON.parse(decompressFromBase64(model.events));
+    const liberoReplacements = [];
+    const substitutions = [];
+    const serves = [];
+    const receptions = [];
+    const sets = [];
+    const spikes = [];
+    const blocks = [];
+    decompressed.forEach(event => {
+        switch (event.event_type) {
+            case 0:
+                liberoReplacements.push(transformToAPILiberoReplacement(event));
+                break;
+            case 1:
+                substitutions.push(transformToAPISubstitution(event));
+                break;
+            case 2:
+                serves.push(transformToAPIServe(event));
+                break;
+            case 3:
+                receptions.push(transformToAPIReception(event));
+                break;
+            case 4:
+                sets.push(transformToAPISet(event));
+                break;
+            case 5:
+                spikes.push(transformToAPISpike(event));
+                break;
+            case 6:
+                blocks.push(transformToAPIBlock(event));
+                break;
+            default:
+                throw new Error('UNKNOWN_EVENT');
+        }
+    });
     const events = [...liberoReplacements, ...substitutions, ...serves, ...receptions, ...sets, ...spikes, ...blocks]
         .sort((e1, e2) => e1.order - e2.order);
     return {

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

@@ -1,7 +1,3 @@
-import { Reception } from '../../service';
-import { ReceptionAttributes, ReceptionModel } from '../models';
 import { APIReception } from '../../api';
-declare function transformToAttributes(event: Reception, rallyId: string): ReceptionAttributes;
-declare function transformToObject(reception: ReceptionModel): Reception;
-declare function transformToAPIObject(event: ReceptionModel): APIReception;
-export { transformToObject as transformToReception, transformToAPIObject as transformToAPIReception, transformToAttributes as transformFromReception };
+declare function transformToAPIObject(event: any): APIReception;
+export { transformToAPIObject as transformToAPIReception };

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

@@ -1,76 +1,11 @@
-import { Reception, ReceptionFailureEnum, ReceptionTypeEnum } from '../../service';
-import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer } from '.';
-function transformToReceptionFailure(failure) {
-    switch (failure) {
-        case ReceptionFailureEnum.NO_FAILURE:
-            return 'NO_FAILURE';
-        case ReceptionFailureEnum.FAULT:
-            return 'FAULT';
-        case ReceptionFailureEnum.MISS:
-            return 'MISS';
-        case ReceptionFailureEnum.OUT_OF_BOUNDS:
-            return 'OUT_OF_BOUNDS';
-        case ReceptionFailureEnum.BAD_PASS:
-            return 'BAD_PASS';
-        default:
-            throw new Error('UNKNOWN_ROLE');
-    }
-}
-function transformFromReceptionFailure(failure) {
-    return ReceptionFailureEnum[failure];
-}
-function transformToReceptionType(type) {
-    switch (type) {
-        case ReceptionTypeEnum.DIG:
-            return 'DIG';
-        case ReceptionTypeEnum.OVERHAND:
-            return 'OVERHAND';
-        case ReceptionTypeEnum.ONE_HAND:
-            return 'ONE_HAND';
-        case ReceptionTypeEnum.OTHER_BODY_PART:
-            return 'OTHER_BODY_PART';
-        default:
-            throw new Error('UNKNOWN_ROLE');
-    }
-}
-function transformFromReceptionType(type) {
-    return ReceptionTypeEnum[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: transformToReceptionFailure(event.failure),
-        type: transformToReceptionType(event.type),
-        event_type: transformFromEventType(event.eventType),
-    };
-}
-function transformToObject(reception) {
-    return new Reception({
-        id: reception.event_id,
-        eventType: transformToEventType(reception.event_type),
-        failure: transformFromReceptionFailure(reception.failure),
-        type: transformFromReceptionType(reception.type),
-        player: transformToPlayer(reception.player),
-        target: transformToCourtTarget(reception.target),
-        order: reception.order,
-        modifier: 1,
-        score: 1,
-        activeTraits: []
-    });
-}
 function transformToAPIObject(event) {
     return {
-        id: event.event_id,
-        eventType: transformToEventType(event.event_type),
-        failure: transformFromReceptionFailure(event.failure),
-        type: transformFromReceptionType(event.type),
-        playerId: event.player_id,
-        target: transformToCourtTarget(event.target),
+        eventType: event.eventType,
+        failure: event.failure,
+        type: event.type,
+        playerId: event.player,
+        target: event.target,
         order: event.order
     };
 }
-export { transformToObject as transformToReception, transformToAPIObject as transformToAPIReception, transformToAttributes as transformFromReception };
+export { transformToAPIObject as transformToAPIReception };

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

@@ -1,7 +1,3 @@
-import { Serve } from '../../service';
-import { ServeAttributes, ServeModel } from '../models';
 import { APIServe } from '../../api';
-declare function transformToAttributes(event: Serve, rallyId: string): ServeAttributes;
-declare function transformToObject(serve: ServeModel): Serve;
-declare function transformToAPIObject(event: ServeModel): APIServe;
-export { transformToObject as transformToServe, transformToAPIObject as transformToAPIServe, transformToAttributes as transformFromServe };
+declare function transformToAPIObject(event: any): APIServe;
+export { transformToAPIObject as transformToAPIServe };

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

@@ -1,78 +1,11 @@
-import { Serve, ServeFailureEnum, ServeTypeEnum } from '../../service';
-import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer } from '.';
-function transformToServeFailure(failure) {
-    switch (failure) {
-        case ServeFailureEnum.NO_FAILURE:
-            return 'NO_FAILURE';
-        case ServeFailureEnum.FAULT:
-            return 'FAULT';
-        case ServeFailureEnum.MISS:
-            return 'MISS';
-        case ServeFailureEnum.OUT_OF_BOUNDS:
-            return 'OUT_OF_BOUNDS';
-        case ServeFailureEnum.NET:
-            return 'NET';
-        default:
-            throw new Error('UNKNOWN_ROLE');
-    }
-}
-function transformFromServeFailure(failure) {
-    return ServeFailureEnum[failure];
-}
-function transformToServeType(type) {
-    switch (type) {
-        case ServeTypeEnum.UNDERHAND:
-            return 'UNDERHAND';
-        case ServeTypeEnum.OVERHAND_TOPSPIN:
-            return 'OVERHAND_TOPSPIN';
-        case ServeTypeEnum.OVERHAND_FLOAT:
-            return 'OVERHAND_FLOAT';
-        case ServeTypeEnum.JUMP_TOPSPIN:
-            return 'JUMP_TOPSPIN';
-        case ServeTypeEnum.JUMP_FLOAT:
-            return 'JUMP_FLOAT';
-        default:
-            throw new Error('UNKNOWN_ROLE');
-    }
-}
-function transformFromServeType(type) {
-    return ServeTypeEnum[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: transformToServeFailure(event.failure),
-        type: transformToServeType(event.type),
-        event_type: transformFromEventType(event.eventType),
-    };
-}
-function transformToObject(serve) {
-    return new Serve({
-        id: serve.event_id,
-        eventType: transformToEventType(serve.event_type),
-        failure: transformFromServeFailure(serve.failure),
-        type: transformFromServeType(serve.type),
-        player: transformToPlayer(serve.player),
-        target: transformToCourtTarget(serve.target),
-        order: serve.order,
-        modifier: 1,
-        score: 1,
-        activeTraits: []
-    });
-}
 function transformToAPIObject(event) {
     return {
-        id: event.event_id,
-        eventType: transformToEventType(event.event_type),
-        failure: transformFromServeFailure(event.failure),
-        type: transformFromServeType(event.type),
-        playerId: event.player_id,
-        target: transformToCourtTarget(event.target),
+        eventType: event.eventType,
+        failure: event.failure,
+        type: event.type,
+        playerId: event.player,
+        target: event.target,
         order: event.order
     };
 }
-export { transformToObject as transformToServe, transformToAPIObject as transformToAPIServe, transformToAttributes as transformFromServe };
+export { transformToAPIObject as transformToAPIServe };

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

@@ -1,7 +1,3 @@
-import { Set } from '../../service';
-import { SetAttributes, SetModel } from '../models';
 import { APISet } from '../../api';
-declare function transformToAttributes(event: Set, rallyId: string): SetAttributes;
-declare function transformToObject(set: SetModel): Set;
-declare function transformToAPIObject(event: SetModel): APISet;
-export { transformToObject as transformToSet, transformToAPIObject as transformToAPISet, transformToAttributes as transformFromSet };
+declare function transformToAPIObject(event: any): APISet;
+export { transformToAPIObject as transformToAPISet };

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

@@ -1,76 +1,11 @@
-import { Set, SetFailureEnum, SetTypeEnum } from '../../service';
-import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer } from '.';
-function transformToSetFailure(failure) {
-    switch (failure) {
-        case SetFailureEnum.NO_FAILURE:
-            return 'NO_FAILURE';
-        case SetFailureEnum.FAULT:
-            return 'FAULT';
-        case SetFailureEnum.MISS:
-            return 'MISS';
-        case SetFailureEnum.OUT_OF_BOUNDS:
-            return 'OUT_OF_BOUNDS';
-        case SetFailureEnum.BAD_PASS:
-            return 'BAD_PASS';
-        default:
-            throw new Error('UNKNOWN_ROLE');
-    }
-}
-function transformFromSetFailure(failure) {
-    return SetFailureEnum[failure];
-}
-function transformToSetType(type) {
-    switch (type) {
-        case SetTypeEnum.OVERHAND:
-            return 'OVERHAND';
-        case SetTypeEnum.UNDERHAND:
-            return 'UNDERHAND';
-        case SetTypeEnum.SPIKE:
-            return 'SPIKE';
-        case SetTypeEnum.DUMP:
-            return 'DUMP';
-        default:
-            throw new Error('UNKNOWN_ROLE');
-    }
-}
-function transformFromSetType(type) {
-    return SetTypeEnum[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: transformToSetFailure(event.failure),
-        type: transformToSetType(event.type),
-        event_type: transformFromEventType(event.eventType)
-    };
-}
-function transformToObject(set) {
-    return new Set({
-        id: set.event_id,
-        eventType: transformToEventType(set.event_type),
-        failure: transformFromSetFailure(set.failure),
-        type: transformFromSetType(set.type),
-        player: transformToPlayer(set.player),
-        target: transformToCourtTarget(set.target),
-        order: set.order,
-        modifier: 1,
-        score: 1,
-        activeTraits: []
-    });
-}
 function transformToAPIObject(event) {
     return {
-        id: event.event_id,
-        eventType: transformToEventType(event.event_type),
-        failure: transformFromSetFailure(event.failure),
-        type: transformFromSetType(event.type),
-        playerId: event.player_id,
-        target: transformToCourtTarget(event.target),
+        eventType: event.eventType,
+        failure: event.failure,
+        type: event.type,
+        playerId: event.player,
+        target: event.target,
         order: event.order
     };
 }
-export { transformToObject as transformToSet, transformToAPIObject as transformToAPISet, transformToAttributes as transformFromSet };
+export { transformToAPIObject as transformToAPISet };

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

@@ -1,7 +1,3 @@
-import { Spike } from '../../service';
-import { SpikeAttributes, SpikeModel } from '../models';
 import { APISpike } from '../../api';
-declare function transformToAttributes(event: Spike, rallyId: string): SpikeAttributes;
-declare function transformToObject(spike: SpikeModel): Spike;
-declare function transformToAPIObject(event: SpikeModel): APISpike;
-export { transformToObject as transformToSpike, transformToAPIObject as transformToAPISpike, transformToAttributes as transformFromSpike };
+declare function transformToAPIObject(event: any): APISpike;
+export { transformToAPIObject as transformToAPISpike };

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/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;
+    protected 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);
+    protected 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}}`;
     }
 }