volleyballsimtypes 0.0.162 → 0.0.165

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

@@ -0,0 +1,13 @@
+import { MatchTeam } from '../../service';
+function transformToAttributes(team, rating) {
+    const teamId = team === MatchTeam.HOME ? rating.match.homeTeam.id : rating.match.awayTeam.id;
+    if (team == null)
+        throw new Error(`INVALID_TEAM: ${teamId}`);
+    return {
+        match_id: rating.match.id,
+        team_id: teamId,
+        p: rating.getExpectedResult(),
+        dR: rating.getPoints(team)
+    };
+}
+export { transformToAttributes as transformFromMatchRating };

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

@@ -0,0 +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;
+export { transformToObject as transformToMatchSetStats, transformToAttributes as transformFromMatchSetStats };

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

@@ -0,0 +1,57 @@
+import { transformToPlayer } from '.';
+function transformToAttributes(stats, setId) {
+    return {
+        player_id: stats.player.id,
+        match_set_id: setId,
+        aces: stats.ace,
+        assists: stats.assists,
+        attempts: stats.attempts,
+        attack_error: stats.attack.error,
+        attack_success: stats.attack.success,
+        serve_error: stats.serve.error,
+        serve_success: stats.serve.success,
+        reception_error: stats.reception.error,
+        reception_success: stats.reception.success,
+        set_error: stats.set.error,
+        set_success: stats.set.success,
+        block_error: stats.block.error,
+        block_success: stats.block.success,
+        rallies_played: stats.ralliesPlayed,
+        kills: stats.kills,
+        contacts: stats.contacts,
+        kill_blocks: stats.killBlocks
+    };
+}
+function transformToObject(model) {
+    return {
+        set: {
+            success: model.set_success,
+            error: model.set_error
+        },
+        attack: {
+            success: model.attack_success,
+            error: model.attack_error
+        },
+        serve: {
+            success: model.serve_success,
+            error: model.serve_error
+        },
+        reception: {
+            success: model.reception_success,
+            error: model.reception_error
+        },
+        block: {
+            success: model.block_success,
+            error: model.block_error
+        },
+        contacts: model.contacts,
+        kills: model.kills,
+        killBlocks: model.kill_blocks,
+        ace: model.aces,
+        assists: model.assists,
+        ralliesPlayed: model.rallies_played,
+        attempts: model.attempts,
+        player: transformToPlayer(model.player)
+    };
+}
+export { transformToObject as transformToMatchSetStats, transformToAttributes as transformFromMatchSetStats };

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

@@ -0,0 +1,5 @@
+import { MatchSetAttributes, MatchSetModel } from '../models';
+import { MatchSet } from '../../service';
+declare function transformToAttributes(set: MatchSet, matchId: string): MatchSetAttributes;
+declare function transformToObject(model: MatchSetModel): MatchSet;
+export { transformToObject as transformToMatchSet, transformToAttributes as transformFromMatchSet };

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

@@ -0,0 +1,35 @@
+import { MatchSet } from '../../service';
+import { transformFromMatchSetStats, transformFromPlayerPosition as fromPosition, transformFromRally, transformToMatchSetStats, transformToPlayerPosition as toPosition, transformToRally } from '.';
+function transformToAttributes(set, matchId) {
+    const homeSetPositions = set.homePlayerPosition.map(position => fromPosition(position, 'HOME', set.id));
+    const awaySetPositions = set.awayPlayerPosition.map(position => fromPosition(position, 'AWAY', set.id));
+    return {
+        match_set_id: set.id,
+        match_id: matchId,
+        order: set.order,
+        is_tie_break: set.isTieBreak,
+        home_score: set.homeScore,
+        away_score: set.awayScore,
+        SetPositions: [...homeSetPositions, ...awaySetPositions],
+        MatchSetStats: (set.stats ?? []).map((stats) => transformFromMatchSetStats(stats, set.id)),
+        Rallies: (set.rallies ?? []).map((rally) => transformFromRally(rally, set.id))
+    };
+}
+function transformToObject(model) {
+    const homePlayerPosition = (model.SetPositions ?? []).filter((p) => p.side === 'HOME').map(toPosition);
+    const awayPlayerPosition = (model.SetPositions ?? []).filter((p) => p.side === 'AWAY').map(toPosition);
+    const stats = (model.MatchSetStats ?? []).map(transformToMatchSetStats);
+    const rallies = (model.Rallies ?? []).map(transformToRally).sort((r1, r2) => r1.order - r2.order);
+    return new MatchSet({
+        id: model.match_id,
+        order: model.order,
+        homeScore: model.home_score,
+        awayScore: model.away_score,
+        isTieBreak: model.is_tie_break,
+        homePlayerPosition,
+        awayPlayerPosition,
+        rallies,
+        stats
+    });
+}
+export { transformToObject as transformToMatchSet, transformToAttributes as transformFromMatchSet };

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

@@ -0,0 +1,5 @@
+import { MatchAttributes, MatchModel } from '../models';
+import { Match } from '../../service';
+declare function transformToAttributes(match: Match): MatchAttributes;
+declare function transformToObject(model: MatchModel): Match;
+export { transformToObject as transformToMatch, transformToAttributes as transformFromMatch };

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

@@ -0,0 +1,28 @@
+import { Match } from '../../service';
+import { transformToMatchSet } from './match-set';
+import { transformToTeam } from './team';
+function transformToAttributes(match) {
+    return {
+        match_id: match.id,
+        away_team: match.awayTeam.id,
+        home_team: match.homeTeam.id,
+        scheduled_date: match.scheduledDate,
+        status: match.status
+    };
+}
+function transformToObject(model) {
+    const sets = (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,
+        status: model.status,
+        homeScore: model.MatchResult?.home_score,
+        awayScore: model.MatchResult?.away_score,
+        winner: model.MatchResult?.WinnerTeam != null ? transformToTeam(model.MatchResult.WinnerTeam) : undefined
+    });
+}
+export { transformToObject as transformToMatch, transformToAttributes as transformFromMatch };

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

@@ -0,0 +1,5 @@
+import { PerformanceStatsAttributes, PerformanceStatsModel } from '../models';
+import { PerformanceStats, Player } from '../../service';
+declare function transformToAttributes(player: Player): PerformanceStatsAttributes;
+declare function transformToObject(model: PerformanceStatsModel): PerformanceStats;
+export { transformToObject as transformToPerformanceStats, transformToAttributes as transformFromPerformanceStats };

package/dist/esm/src/data/transformers/performance-stats.js

@@ -0,0 +1,33 @@
+import { PerformanceStats } from '../../service';
+function transformToAttributes(player) {
+    return {
+        player_id: player.id,
+        back_attack: player.stats.backAttack,
+        block: player.stats.block,
+        awareness: player.stats.awareness,
+        defense: player.stats.defense,
+        jump: player.stats.jump,
+        pass: player.stats.pass,
+        serve: player.stats.serve,
+        reception: player.stats.reception,
+        setting: player.stats.setting,
+        spike: player.stats.spike,
+        stamina: player.stats.stamina
+    };
+}
+function transformToObject(model) {
+    return new PerformanceStats({
+        awareness: model.awareness,
+        defense: model.defense,
+        jump: model.jump,
+        pass: model.pass,
+        serve: model.serve,
+        reception: model.reception,
+        setting: model.setting,
+        spike: model.spike,
+        stamina: model.stamina,
+        block: model.block,
+        backAttack: model.back_attack
+    });
+}
+export { transformToObject as transformToPerformanceStats, transformToAttributes as transformFromPerformanceStats };

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

@@ -0,0 +1,3 @@
+import { PlayerTeamAttributes } from '../models';
+declare function transformToAttributes(playerId: string, teamId: string, jerseyNumber: number, active?: boolean): PlayerTeamAttributes;
+export { transformToAttributes as transformFromPlayerTeam };

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

@@ -0,0 +1,9 @@
+function transformToAttributes(playerId, teamId, jerseyNumber, active = false) {
+    return {
+        player_id: playerId,
+        team_id: teamId,
+        jersey_number: jerseyNumber,
+        active
+    };
+}
+export { transformToAttributes as transformFromPlayerTeam };

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

@@ -0,0 +1,5 @@
+import { PlayerAttributes, PlayerModel } from '../models';
+import { Player } from '../../service';
+declare function transformToAttributes(player: Player): PlayerAttributes;
+declare function transformToObject(model: PlayerModel): Player;
+export { transformToObject as transformToPlayer, transformToAttributes as transformFromPlayer };

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

@@ -0,0 +1,28 @@
+import { Player } from '../../service';
+import { transformFromPerformanceStats, transformFromRole, transformToCountry, transformToPerformanceStats, transformToRole, transformToTrait } from '.';
+function transformToAttributes(player) {
+    return {
+        player_id: player.id,
+        country_id: player.country.id,
+        first_name: player.name.first,
+        last_name: player.name.last,
+        roles: player.roles.map(transformFromRole),
+        PerformanceStat: transformFromPerformanceStats(player),
+        rarity: player.rarity
+    };
+}
+function transformToObject(model) {
+    return new Player({
+        id: model.player_id,
+        name: {
+            first: model.first_name,
+            last: model.last_name
+        },
+        country: transformToCountry(model.country),
+        roles: model.roles.map(transformToRole),
+        traits: model.Traits.map(transformToTrait),
+        stats: transformToPerformanceStats(model.PerformanceStat),
+        rarity: model.rarity
+    });
+}
+export { transformToObject as transformToPlayer, transformToAttributes as transformFromPlayer };

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

@@ -0,0 +1,5 @@
+import { RallyAttributes, RallyModel } from '../models';
+import { Rally } from '../../service';
+declare function transformToAttributes(rally: Rally, setId: string): RallyAttributes;
+declare function transformToObject(model: RallyModel): Rally;
+export { transformToObject as transformToRally, transformToAttributes as transformFromRally };

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

@@ -0,0 +1,23 @@
+import { Rally } from '../../service';
+import { compressToBase64, decompressFromBase64 } from 'lz-string';
+import { transformToTeam } from './team';
+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,
+        events: compressToBase64(events)
+    };
+}
+function transformToObject(model) {
+    const events = JSON.parse(decompressFromBase64(model.events));
+    return new Rally({
+        id: model.rally_id,
+        order: model.order,
+        servingTeam: transformToTeam(model.ServingTeam),
+        events
+    });
+}
+export { transformToObject as transformToRally, transformToAttributes as transformFromRally };

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

@@ -0,0 +1,5 @@
+import { Role } from '../../service';
+import { RoleType } from '../models';
+declare function transformToType(role: Role): RoleType;
+declare function transformFromType(role: RoleType): Role;
+export { transformToType as transformFromRole, transformFromType as transformToRole };

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

@@ -0,0 +1,21 @@
+import { Role } from '../../service';
+function transformToType(role) {
+    switch (role) {
+        case Role.SETTER:
+            return 'SETTER';
+        case Role.LIBERO:
+            return 'LIBERO';
+        case Role.MIDDLE_BLOCKER:
+            return 'MIDDLE_BLOCKER';
+        case Role.OUTSIDE_HITTER:
+            return 'OUTSIDE_HITTER';
+        case Role.OPPOSITE_HITTER:
+            return 'OPPOSITE_HITTER';
+        default:
+            throw new Error('UNKNOWN_ROLE');
+    }
+}
+function transformFromType(role) {
+    return Role[role];
+}
+export { transformToType as transformFromRole, transformFromType as transformToRole };

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

@@ -0,0 +1,4 @@
+import { CompetitionMatchAttributes } from '../models';
+import { Match } from '../../service';
+declare function transformToAttributes(seasonId: string, match: Match, index: number): CompetitionMatchAttributes;
+export { transformToAttributes as transformFromSeasonMatch };

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

@@ -0,0 +1,13 @@
+import { Stage } from '../../service';
+import { transformFromMatch } from './match';
+import { transformFromStage } from './stage';
+function transformToAttributes(seasonId, match, index) {
+    return {
+        competition_id: seasonId,
+        match_id: match.id,
+        index,
+        stage: transformFromStage(Stage.LEAGUE),
+        Match: transformFromMatch(match)
+    };
+}
+export { transformToAttributes as transformFromSeasonMatch };

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

@@ -0,0 +1,5 @@
+import { CompetitionAttributes, CompetitionModel } from '../models';
+import { Season } from '../../service';
+declare function transformToAttributes(season: Season, leagueId: string): CompetitionAttributes;
+declare function transformToObject(model: CompetitionModel): Season;
+export { transformToObject as transformToSeason, transformToAttributes as transformFromSeason };

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

@@ -0,0 +1,36 @@
+import { transformFromSeasonMatch, transformToIteration, transformToMatch, transformToTeam } from '.';
+import { Season } from '../../service';
+function transformToAttributes(season, leagueId) {
+    const matches = (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;
+    return {
+        competition_id: season.id,
+        type: 'LEAGUE',
+        iteration: season.iteration.id,
+        LeagueSeason: { league_id: leagueId, competition_id: season.id },
+        CompetitionChampion: champion,
+        CompetitionMatches: matches,
+        CompetitionTeams: teams,
+        status: season.status
+    };
+}
+function transformToObject(model) {
+    return new Season({
+        id: model.competition_id,
+        matches: (model.CompetitionMatches ?? []).map((matches) => transformToMatch(matches.Match)),
+        iteration: transformToIteration(model.Iteration),
+        teams: model.Teams != null ? model.Teams.map(transformToTeam) : [],
+        champion: model.CompetitionChampion != null ? transformToTeam(model.CompetitionChampion.team) : undefined,
+        status: model.status
+    });
+}
+export { transformToObject as transformToSeason, transformToAttributes as transformFromSeason };

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

@@ -0,0 +1,5 @@
+import { PlayerPosition } from '../../service';
+import { SetPositionAttributes, SetPositionModel, Side } from '../models';
+declare function transformToAttributes(playerPosition: PlayerPosition, side: Side, setId: string): SetPositionAttributes;
+declare function transformToObject(model: SetPositionModel): PlayerPosition;
+export { transformToObject as transformToPlayerPosition, transformToAttributes as transformFromPlayerPosition };

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

@@ -0,0 +1,16 @@
+import { transformFromCourtPosition, transformToCourtPosition } from '.';
+function transformToAttributes(playerPosition, side, setId) {
+    return {
+        match_set_id: setId,
+        side,
+        court_position: transformFromCourtPosition(playerPosition.position),
+        player_id: playerPosition.playerId
+    };
+}
+function transformToObject(model) {
+    return {
+        playerId: model.player_id,
+        position: transformToCourtPosition(model.court_position)
+    };
+}
+export { transformToObject as transformToPlayerPosition, transformToAttributes as transformFromPlayerPosition };

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

@@ -0,0 +1,5 @@
+import { Stage } from '../../service';
+import { CompetitionStage } from '../models';
+declare function transformToType(stage: Stage): CompetitionStage;
+declare function transformFromType(s: CompetitionStage): Stage;
+export { transformToType as transformFromStage, transformFromType as transformToStage };

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

@@ -0,0 +1,21 @@
+import { Stage } from '../../service';
+function transformToType(stage) {
+    switch (stage) {
+        case Stage.ROUND_OF_8:
+            return 'ROUND_OF_8';
+        case Stage.QUARTERFINALS:
+            return 'QUARTERFINALS';
+        case Stage.SEMIFINALS:
+            return 'SEMIFINALS';
+        case Stage.FINAL:
+            return 'FINAL';
+        case Stage.LEAGUE:
+            return 'LEAGUE';
+        default:
+            throw new Error('UNKNOWN_ROLE');
+    }
+}
+function transformFromType(s) {
+    return Stage[s];
+}
+export { transformToType as transformFromStage, transformFromType as transformToStage };

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

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

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

@@ -0,0 +1,26 @@
+import { Team } from '../../service';
+import { transformFromCoach, transformToCoach, transformToCountry, transformToPlayer } from '.';
+function transformToAttributes(team) {
+    return {
+        team_id: team.id,
+        name: team.name,
+        short_name: team.shortName,
+        coach_id: team.coach?.id,
+        country_id: team.country?.id,
+        league_id: team.league?.id,
+        coach: team.coach != null ? transformFromCoach(team.coach) : undefined,
+        rating: team.rating
+    };
+}
+function transformToObject(team) {
+    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
+    });
+}
+export { transformToObject as transformToTeam, transformToAttributes as transformFromTeam };

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

@@ -0,0 +1,5 @@
+import { TournamentMatch } from '../../service';
+import { CompetitionMatchAttributes, CompetitionMatchModel } from '../models';
+declare function transformToAttributes(tournamentMatch: TournamentMatch, tournamentId: string): CompetitionMatchAttributes;
+declare function transformToObject(model: CompetitionMatchModel): TournamentMatch;
+export { transformToObject as transformToTournamentMatch, transformToAttributes as transformFromTournamentMatch };

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

@@ -0,0 +1,19 @@
+import { TournamentMatch } from '../../service';
+import { transformFromMatch, transformFromStage, transformToMatch, transformToStage } from '.';
+function transformToAttributes(tournamentMatch, tournamentId) {
+    return {
+        competition_id: tournamentId,
+        match_id: tournamentMatch.match.id,
+        index: tournamentMatch.index,
+        stage: transformFromStage(tournamentMatch.stage),
+        Match: transformFromMatch(tournamentMatch.match)
+    };
+}
+function transformToObject(model) {
+    return new TournamentMatch({
+        stage: transformToStage(model.stage),
+        match: transformToMatch(model.Match),
+        index: model.index
+    });
+}
+export { transformToObject as transformToTournamentMatch, transformToAttributes as transformFromTournamentMatch };

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

@@ -0,0 +1,5 @@
+import { CompetitionAttributes, CompetitionModel } from '../models';
+import { Tournament } from '../../service';
+declare function transformToAttributes(tournament: Tournament): CompetitionAttributes;
+declare function transformToObject(model: CompetitionModel): Tournament;
+export { transformToObject as transformToTournament, transformToAttributes as transformFromTournament };

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

@@ -0,0 +1,38 @@
+import { transformFromTournamentMatch, transformToIteration, transformToTeam, transformToTournamentMatch } from '.';
+import { Tournament } from '../../service';
+function transformToAttributes(tournament) {
+    const matches = tournament.matches.map((match) => transformFromTournamentMatch(match, tournament.id));
+    const teams = tournament.teams.map((team) => ({
+        competition_id: tournament.id,
+        team_id: team.id
+    }));
+    const champion = (tournament.champion != null)
+        ? {
+            competition_id: tournament.id,
+            team_id: tournament.champion.id
+        }
+        : undefined;
+    return {
+        competition_id: tournament.id,
+        type: 'TOURNAMENT',
+        iteration: tournament.iteration.id,
+        CompetitionChampion: champion,
+        CompetitionMatches: matches,
+        CompetitionTeams: teams,
+        status: tournament.status
+    };
+}
+function transformToObject(model) {
+    const champion = model.CompetitionChampion?.team != null
+        ? transformToTeam(model.CompetitionChampion.team)
+        : undefined;
+    return new Tournament({
+        id: model.competition_id,
+        iteration: transformToIteration(model.Iteration),
+        matches: (model.CompetitionMatches ?? []).map(transformToTournamentMatch),
+        teams: (model.Teams ?? []).map(transformToTeam),
+        status: model.status,
+        champion
+    });
+}
+export { transformToObject as transformToTournament, transformToAttributes as transformFromTournament };

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

@@ -0,0 +1,5 @@
+import { Trait } from '../../service';
+import { TraitAttributes, TraitModel } from '../models';
+declare function transformToAttributes(trait: Trait): TraitAttributes;
+declare function transformToObject(model: TraitModel): Trait;
+export { transformToObject as transformToTrait, transformToAttributes as transformFromTrait };

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

@@ -0,0 +1,15 @@
+import { Trait } from '../../service';
+function transformToAttributes(trait) {
+    return {
+        trait_id: trait.id,
+        name: trait.name
+    };
+}
+function transformToObject(model) {
+    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, transformToAttributes as transformFromTrait };