volleyballsimtypes 0.0.122 → 0.0.124

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

@@ -11,21 +11,23 @@ function transformToAttributes(match) {
 }
 function transformToObject(model) {
     const sets = model.MatchSets == null || model.MatchSets.length < 1
-        ? [] : model.MatchSets.map(transformToMatchSet)
-        .sort((s1, s2) => s1.order - s2.order);
+        ? []
+        : model.MatchSets.map(transformToMatchSet)
+            .sort((s1, s2) => s1.order - s2.order);
     return new Match({
         id: model.match_id,
         homeTeam: transformToTeam(model.HomeTeam),
         awayTeam: transformToTeam(model.AwayTeam),
         scheduledDate: new Date(model.scheduled_date),
-        sets: sets,
+        sets,
         isSimulated: model.is_simulated
     });
 }
 function transformToAPIObject(match, competition) {
     const sets = match.MatchSets == null || match.MatchSets.length < 1
-        ? [] : match.MatchSets.map(transformToAPIMatchSet)
-        .sort((s1, s2) => s1.order - s2.order);
+        ? []
+        : match.MatchSets.map(transformToAPIMatchSet)
+            .sort((s1, s2) => s1.order - s2.order);
     return {
         id: match.match_id,
         homeTeam: transformToAPITeam(match.HomeTeam),

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

@@ -24,10 +24,12 @@ function transformToObject(model) {
     });
 }
 function transformToAPIObject(model, team, jerseyNumber) {
-    const generalStats = model.PerformanceStat != null ? GeneralStat.getStats().map(stat => ({
-        name: stat,
-        value: GeneralStat.calculateScore(transformToPerformanceStats(model.PerformanceStat), stat)
-    })) : [];
+    const generalStats = model.PerformanceStat != null
+        ? GeneralStat.getStats().map(stat => ({
+            name: stat,
+            value: GeneralStat.calculateScore(transformToPerformanceStats(model.PerformanceStat), stat)
+        }))
+        : [];
     const gameStats = model.MatchSetStats != null ? model.MatchSetStats.map(transformToAPIMatchSetStats) : [];
     if (gameStats.length > 0) {
         gameStats.push(calculateMatchStats(gameStats));

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

@@ -1,37 +1,71 @@
 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 { 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 => {
+        switch (e.eventType) {
+            case EventTypeEnum.BLOCK:
+                return e.toString();
+            case EventTypeEnum.LIBERO_REPLACEMENT:
+                return e.toString();
+            case EventTypeEnum.SET:
+                return e.toString();
+            case EventTypeEnum.SERVE:
+                return e.toString();
+            case EventTypeEnum.SPIKE:
+                return e.toString();
+            case EventTypeEnum.RECEPTION:
+                return e.toString();
+            case EventTypeEnum.SUBSTITUTION:
+                return e.toString();
+            default:
+                throw new Error('UNKNOWN_EVENT_TYPE');
+        }
+    }).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 +76,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/season.js

@@ -1,16 +1,19 @@
 import { transformFromSeasonMatch, transformToAPILeague, transformToAPIMatch, transformToAPITeam, transformToIteration, transformToMatch, transformToTeam } from '.';
 import { Season } from '../../service';
 function transformToAttributes(season, leagueId) {
-    const matches = season.matches != null ?
-        season.matches.map((match, index) => transformFromSeasonMatch(season.id, match, index)) : [];
+    const matches = season.matches != null
+        ? season.matches.map((match, index) => transformFromSeasonMatch(season.id, match, index))
+        : [];
     const teams = season.teams.map(team => ({
         competition_id: season.id,
         team_id: team.id
     }));
-    const champion = season.champion != null ? {
-        competition_id: season.id,
-        team_id: season.champion?.id
-    } : undefined;
+    const champion = season.champion != null
+        ? {
+            competition_id: season.id,
+            team_id: season.champion?.id
+        }
+        : undefined;
     return {
         competition_id: season.id,
         type: 'LEAGUE',
@@ -22,8 +25,9 @@ function transformToAttributes(season, leagueId) {
     };
 }
 function transformToObject(model) {
-    const matches = model.CompetitionMatches != null ?
-        model.CompetitionMatches.map(matches => transformToMatch(matches.Match)) : [];
+    const matches = model.CompetitionMatches != null
+        ? model.CompetitionMatches.map(matches => transformToMatch(matches.Match))
+        : [];
     return new Season({
         id: model.competition_id,
         matches,
@@ -34,31 +38,38 @@ function transformToObject(model) {
 }
 function transformToAPIObject(model) {
     const season = transformToObject(model);
-    const matches = model.CompetitionMatches != null ?
-        model.CompetitionMatches.map(matches => transformToAPIMatch(matches.Match)) : [];
+    const matches = model.CompetitionMatches != null
+        ? model.CompetitionMatches.map(matches => transformToAPIMatch(matches.Match))
+        : [];
     const teams = model.Teams != null ? model.Teams.map(transformToAPITeam) : [];
-    const standings = season.standings.map(standing => ({
-        team: teams.find(t => standing.team.id === t.id),
-        lost03: standing.lost03,
-        lost13: standing.lost13,
-        lost23: standing.lost23,
-        matchesLost: standing.matchesLost,
-        matchesWon: standing.matchesWon,
-        points: standing.points,
-        pointsLost: standing.pointsLost,
-        pointsRatio: standing.pointsRatio,
-        pointsWon: standing.pointsWon,
-        setsLost: standing.setsLost,
-        setsRatio: standing.setsRatio,
-        setsWon: standing.setsWon,
-        won30: standing.won30,
-        won31: standing.won31,
-        won32: standing.won32,
-        totalMatches: standing.totalMatches
-    }));
+    const standings = season.standings.map(standing => {
+        const team = teams.find(t => standing.team.id === t.id);
+        if (team == null) {
+            throw new Error('TEAM_NOT_FOUND');
+        }
+        return {
+            team,
+            lost03: standing.lost03,
+            lost13: standing.lost13,
+            lost23: standing.lost23,
+            matchesLost: standing.matchesLost,
+            matchesWon: standing.matchesWon,
+            points: standing.points,
+            pointsLost: standing.pointsLost,
+            pointsRatio: standing.pointsRatio,
+            pointsWon: standing.pointsWon,
+            setsLost: standing.setsLost,
+            setsRatio: standing.setsRatio,
+            setsWon: standing.setsWon,
+            won30: standing.won30,
+            won31: standing.won31,
+            won32: standing.won32,
+            totalMatches: standing.totalMatches
+        };
+    });
     return {
         id: model.competition_id,
-        matches: matches,
+        matches,
         iteration: model.iteration,
         league: model.LeagueSeason?.league != null ? transformToAPILeague(model.LeagueSeason.league) : undefined,
         champion: model.CompetitionChampion != null ? transformToAPITeam(model.CompetitionChampion.team) : undefined,

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 };