volleyballsimtypes 0.0.7 → 0.0.8

package/src/data/transformers/set.ts

@@ -1,98 +0,0 @@
-import { Rally, Set, SetFailure, SetType } from '../../service'
-import { SetAttributes, SetModel } from '../models'
-import { transformFromEventType, transformToEventType } from './event-type'
-import { transformFromCourtTarget, transformToCourtTarget } from './court-target'
-import { transformToPlayer } from './player'
-import { APISet } from '../../routing'
-
-type setFailure = 'NO_FAILURE' | 'FAULT' | 'MISS' | 'OUT_OF_BOUNDS' | 'BAD_PASS'
-type serveType = 'OVERHAND' | 'UNDERHAND' | 'SPIKE' | 'DUMP'
-
-function transformToSetFailure (failure: SetFailure): setFailure {
-  switch (failure) {
-    case SetFailure.NO_FAILURE:
-      return 'NO_FAILURE'
-    case SetFailure.FAULT:
-      return 'FAULT'
-    case SetFailure.MISS:
-      return 'MISS'
-    case SetFailure.OUT_OF_BOUNDS:
-      return 'OUT_OF_BOUNDS'
-    case SetFailure.BAD_PASS:
-      return 'BAD_PASS'
-    default:
-      throw new Error('UNKNOWN_ROLE')
-  }
-}
-
-function transformFromSetFailure (failure: setFailure): SetFailure {
-  return SetFailure[failure]
-}
-
-function transformToSetType (type: SetType): serveType {
-  switch (type) {
-    case SetType.OVERHAND:
-      return 'OVERHAND'
-    case SetType.UNDERHAND:
-      return 'UNDERHAND'
-    case SetType.SPIKE:
-      return 'SPIKE'
-    case SetType.DUMP:
-      return 'DUMP'
-    default:
-      throw new Error('UNKNOWN_ROLE')
-  }
-}
-
-function transformFromSetType (type: serveType): SetType {
-  return SetType[type]
-}
-
-function transformToAttributes (event: Set, rally: Rally): SetAttributes {
-  return {
-    event_id: event.id,
-    player_id: event.player.id,
-    rally_id: rally.id,
-    order: event.order,
-    modifier: event.modifier,
-    score: event.score,
-    target: transformFromCourtTarget(event.target),
-    failure: transformToSetFailure(event.failure),
-    type: transformToSetType(event.type),
-    event_type: transformFromEventType(event.eventType)
-  }
-}
-
-function transformToObject (set: SetModel): 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),
-    modifier: set.modifier,
-    order: set.order,
-    score: set.score
-  })
-}
-
-function transformToAPIObject (event: SetModel): APISet {
-  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),
-    modifier: event.modifier,
-    order: event.order,
-    score: event.score
-  }
-}
-
-export {
-  transformToObject as transformToSet,
-  transformToAPIObject as transformToAPISet,
-  transformToAttributes as transformFromSet
-}

package/src/data/transformers/spike.ts

@@ -1,102 +0,0 @@
-import { Rally, Spike, SpikeFailure, SpikeType } from '../../service'
-import { SpikeAttributes, SpikeModel } from '../models'
-import { transformFromEventType, transformToEventType } from './event-type'
-import { transformFromCourtTarget, transformToCourtTarget } from './court-target'
-import { transformToPlayer } from './player'
-import { APISpike } from '../../routing'
-
-type spikeFailure = 'NO_FAILURE' | 'FAULT' | 'MISS' | 'OUT_OF_BOUNDS' | 'NET'
-type spikeType = 'CROSS_SHOT' | 'LINE_SHOT' | 'TOOL_SHOT' | 'TIP' | 'DOWN_BALL' | 'OVERHAND'
-
-function transformToSpikeFailure (failure: SpikeFailure): spikeFailure {
-  switch (failure) {
-    case SpikeFailure.NO_FAILURE:
-      return 'NO_FAILURE'
-    case SpikeFailure.FAULT:
-      return 'FAULT'
-    case SpikeFailure.MISS:
-      return 'MISS'
-    case SpikeFailure.OUT_OF_BOUNDS:
-      return 'OUT_OF_BOUNDS'
-    case SpikeFailure.NET:
-      return 'NET'
-    default:
-      throw new Error('UNKNOWN_ROLE')
-  }
-}
-
-function transformFromSpikeFailure (failure: spikeFailure): SpikeFailure {
-  return SpikeFailure[failure]
-}
-
-function transformToSpikeType (type: SpikeType): spikeType {
-  switch (type) {
-    case SpikeType.CROSS_SHOT:
-      return 'CROSS_SHOT'
-    case SpikeType.LINE_SHOT:
-      return 'LINE_SHOT'
-    case SpikeType.TOOL_SHOT:
-      return 'TOOL_SHOT'
-    case SpikeType.TIP:
-      return 'TIP'
-    case SpikeType.DOWN_BALL:
-      return 'DOWN_BALL'
-    case SpikeType.OVERHAND:
-      return 'OVERHAND'
-    default:
-      throw new Error('UNKNOWN_ROLE')
-  }
-}
-
-function transformFromSpikeType (type: spikeType): SpikeType {
-  return SpikeType[type]
-}
-
-function transformToAttributes (event: Spike, rally: Rally): SpikeAttributes {
-  return {
-    event_id: event.id,
-    player_id: event.player.id,
-    rally_id: rally.id,
-    order: event.order,
-    modifier: event.modifier,
-    score: event.score,
-    target: transformFromCourtTarget(event.target),
-    failure: transformToSpikeFailure(event.failure),
-    type: transformToSpikeType(event.type),
-    event_type: transformFromEventType(event.eventType)
-  }
-}
-
-function transformToObject (spike: SpikeModel): 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),
-    modifier: spike.modifier,
-    order: spike.order,
-    score: spike.score
-  })
-}
-
-function transformToAPIObject (event: SpikeModel): APISpike {
-  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),
-    modifier: event.modifier,
-    order: event.order,
-    score: event.score
-  }
-}
-
-export {
-  transformToObject as transformToSpike,
-  transformToAPIObject as transformToAPISpike,
-  transformToAttributes as transformFromSpike
-}

package/src/data/transformers/substitution.ts

@@ -1,42 +0,0 @@
-import { Rally, Substitution } from '../../service'
-import { SubstitutionAttributes, SubstitutionModel } from '../models'
-import { transformFromEventType, transformToEventType } from './event-type'
-import { transformToPlayer } from './player'
-import { APISubstitution } from '../../routing'
-
-function transformToAttributes (event: Substitution, rally: Rally): SubstitutionAttributes {
-  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: rally.id
-  }
-}
-
-function transformToObject (event: SubstitutionModel): Substitution {
-  return new Substitution({
-    id: event.event_id,
-    player: transformToPlayer(event.player),
-    playerOut: transformToPlayer(event.player_out_Player),
-    order: event.order,
-    eventType: transformToEventType(event.event_type)
-  })
-}
-
-function transformToAPIObject (event: SubstitutionModel): APISubstitution {
-  return {
-    id: event.event_id,
-    eventType: transformToEventType(event.event_type),
-    playerId: event.player_id,
-    order: event.order,
-    playerOutId: event.player_out
-  }
-}
-
-export {
-  transformToObject as transformToSubstitution,
-  transformToAPIObject as transformToAPISubstitution,
-  transformToAttributes as transformFromSubstitution
-}

package/src/data/transformers/team.ts

@@ -1,45 +0,0 @@
-import { Team } from '../../service'
-import { TeamAttributes, TeamModel } from '../models'
-import { transformToCountry } from './country'
-import { transformToCoach } from './coach'
-import { transformToAPIPlayer, transformToPlayer } from './player'
-import { APITeam } from '../../routing'
-
-function transformToAttributes (team: Team): TeamAttributes {
-  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
-  }
-}
-
-function transformToObject (team: TeamModel): 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.Players != null ? team.Players.map(transformToPlayer) : []
-  })
-}
-
-function transformToAPIObject (team: TeamModel): APITeam {
-  return {
-    id: team.team_id,
-    name: team.name,
-    shortName: team.short_name,
-    country: transformToCountry(team.country),
-    coach: transformToCoach(team.coach),
-    roster: team.Players != null ? team.Players.map(transformToAPIPlayer) : []
-  }
-}
-
-export {
-  transformToObject as transformToTeam,
-  transformToAPIObject as transformToAPITeam,
-  transformToAttributes as transformFromTeam
-}

package/src/data/transformers/trait.ts

@@ -1,37 +0,0 @@
-import { Trait } from '../../service/player/trait'
-import { APITrait } from '../../routing'
-
-type trait = 'MARKSMAN' | 'MOVING_WALL' | 'MASTER_MIND' | 'METEOR_SERVE' | 'VIGOROUS' | 'GUARDIAN'
-
-function transformToType (trait: Trait): trait {
-  switch (trait.name) {
-    case 'Marksman':
-      return 'MARKSMAN'
-    case 'Master Mind':
-      return 'MASTER_MIND'
-    case 'Moving Wall':
-      return 'MOVING_WALL'
-    case 'Meteor Serve':
-      return 'METEOR_SERVE'
-    case 'Vigorous':
-      return 'VIGOROUS'
-    case 'Guardian':
-      return 'GUARDIAN'
-    default:
-      throw new Error('UNKNOWN_TRAIT')
-  }
-}
-
-function transformFromType (trait: trait): Trait {
-  return Trait[trait]
-}
-
-function transformToEnum (trait: trait): APITrait {
-  return APITrait[trait]
-}
-
-export {
-  transformToType as transformFromTrait,
-  transformFromType as transformToTrait,
-  transformToEnum as transformToAPITrait
-}

package/src/index.ts

@@ -1,7 +0,0 @@
-import { validateRoleFormulas } from './service/main'
-
-validateRoleFormulas()
-
-export * from './service'
-export * from './routing'
-export * from './data'

package/src/routing/events.ts

@@ -1,60 +0,0 @@
-import { EventType } from '../service/event/rally-event'
-import { LiberoReplacementType } from '../service/event/libero-replacement'
-import { CourtTarget } from '../service/match'
-import { SpikeFailure, SpikeType } from '../service/event/spike'
-import { SetFailure, SetType } from '../service/event/set'
-import { ServeFailure, ServeType } from '../service/event/serve'
-import { BlockFailure, BlockType } from '../service/event/block'
-import { ReceptionFailure, ReceptionType } from '../service/event/reception'
-
-export interface APIEvent {
-  id: string
-  order: number
-  playerId: string
-  eventType: EventType
-}
-
-export interface APILiberoReplacement extends APIEvent {
-  type: LiberoReplacementType
-  liberoId: string
-}
-
-export interface APISubstitution extends APIEvent {
-  playerOutId: string
-}
-
-export interface APIInPlayEvent extends APIEvent {
-  target: CourtTarget
-  modifier: number
-  score: number
-}
-
-export interface APIScore extends APIEvent {
-  teamId: string
-}
-
-export interface APIServe extends APIInPlayEvent {
-  type: ServeType
-  failure: ServeFailure
-}
-
-export interface APISet extends APIInPlayEvent {
-  type: SetType
-  failure: SetFailure
-}
-
-export interface APISpike extends APIInPlayEvent {
-  failure: SpikeFailure
-  type: SpikeType
-}
-
-export interface APIReception extends APIInPlayEvent {
-  type: ReceptionType
-  failure: ReceptionFailure
-}
-
-export interface APIBlock extends APIInPlayEvent {
-  failure: BlockFailure
-  type: BlockType
-  blockers: string[]
-}

package/src/routing/index.ts

@@ -1,5 +0,0 @@
-export * from './events'
-export * from './league'
-export * from './match'
-export * from './player'
-export * from './team'

package/src/routing/league.ts

@@ -1,15 +0,0 @@
-import { League, Standing } from '../service/league'
-import { APITeam } from './team'
-import { APIMatch } from './match'
-
-export interface APILeague {
-  
-}
-export interface APISeason {
-  id: string
-  teams: APITeam[]
-  matches: APIMatch[]
-  iteration: number
-  standings: Standing[]
-  league: League
-}

package/src/routing/match.ts

@@ -1,52 +0,0 @@
-import { EventStat, PlayerPosition, SetStatistics } from '../service/match'
-import { APIEvent } from './events'
-import { Team } from '../service/team'
-import { Player } from '../service/player'
-import { APITeam } from './team'
-
-export interface APIMatch {
-  id: string
-  homeTeam: APITeam
-  awayTeam: APITeam
-  sets: APIMatchSet[]
-  scheduledDate: Date
-}
-
-export interface APIMatchSet {
-  id: string
-  order: number
-  isTieBreak: boolean
-  homeLiberoId: string | undefined
-  awayLiberoId: string | undefined
-  homeScore: number
-  awayScore: number
-  stats: APISetStatistics[]
-  rallies: APIRally[]
-}
-
-export interface APIRally {
-  id: string
-  servingTeamId: string
-  events: APIEvent[]
-  homePlayerPosition: PlayerPosition[]
-  awayPlayerPosition: PlayerPosition[]
-  order: number
-}
-
-export interface APISetStatistics {
-  order: number
-  playerId: string
-  ace: number
-  attempts: number
-  contacts: number
-  ralliesPlayed: number
-  serve: EventStat
-  reception: EventStat
-  set: EventStat
-  attack: EventStat
-  block: EventStat
-  kills: number
-  killBlocks: number
-  assists: number
-  setsPlayed?: number
-}

package/src/routing/player.ts

@@ -1,24 +0,0 @@
-import { Country } from '../service/country'
-import { Name, Role, Stat } from '../service/player'
-import { APISetStatistics } from './match'
-
-export enum APITrait {
-  MASTER_MIND = 'Master Mind',
-  MOVING_WALL = 'Moving Wall',
-  MARKSMAN = 'Marksman',
-  METEOR_SERVE = 'Meteor Serve',
-  VIGOROUS = 'Vigorous',
-  GUARDIAN = 'Guardian'
-}
-
-export interface APIPlayer {
-  id: string
-  name: Name
-  country: Country
-  gameStats: APISetStatistics[]
-  roles: Role[]
-  traits: APITrait[]
-  jerseyNumber: number
-  team: string
-  generalStats: Stat[]
-}

package/src/routing/team.ts

@@ -1,14 +0,0 @@
-import { Coach } from '../service/coach'
-import { Country } from '../service/country'
-import { APIPlayer } from './player'
-import { APILeague } from './league'
-
-export interface APITeam {
-  id: string
-  roster: APIPlayer[]
-  name: string
-  shortName: string
-  coach: Coach
-  country: Country
-  league?: string
-}

package/src/service/coach/__stubs__/index.ts

@@ -1,46 +0,0 @@
-import { Coach } from '../coach'
-import { Formation } from '../formation'
-import { countries, country } from '../../country/__stubs__'
-
-export const coaches = [
-  new Coach({
-    name: { first: 'Jameson', last: 'Richardson' },
-    id: '8cd3a3fb-2034-487c-a041-fb06de0e374b',
-    country: countries[0],
-    formation: Formation['4-2'],
-    substitutionTolerance: 5
-  }),
-  new Coach({
-    id: '1be93fd6-62c4-4434-aaa0-730212ab72d7',
-    name: { first: 'Hunter', last: 'Rivera' },
-    country: countries[1],
-    formation: Formation['5-1'],
-    substitutionTolerance: 5
-  }),
-  new Coach({
-    id: 'a96b6732-2a71-451e-8973-c264446c594d',
-    name: {
-      first: 'Jonathan',
-      last: 'Jenkins'
-    },
-    country: countries[2],
-    formation: Formation['5-1'],
-    substitutionTolerance: 5
-  }),
-  new Coach({
-    id: '34086150-9692-4371-a5a4-0349170339e7',
-    name: { first: 'Noah', last: 'Adams' },
-    country: countries[3],
-    formation: Formation['6-2'],
-    substitutionTolerance: 5
-  })
-
-]
-
-export const coach: Coach = new Coach({
-  id: '1ad40ceb-b5ad-4e20-953c-3c1f050ac61d',
-  formation: Formation['6-2'],
-  name: { first: 'Julio', last: 'Velasco' },
-  country,
-  substitutionTolerance: 5
-})

package/src/service/coach/coach.test.ts

@@ -1,10 +0,0 @@
-import { describe, expect, test } from '@jest/globals'
-import { coach } from './__stubs__'
-
-describe('Coach Test Module', () => {
-  test('Should instantiate object properly', () => {
-    expect(coach.id).toEqual('1ad40ceb-b5ad-4e20-953c-3c1f050ac61d')
-    expect(coach.name.first).toEqual('Julio')
-    expect(coach.name.last).toEqual('Velasco')
-  })
-})

package/src/service/coach/coach.ts

@@ -1,30 +0,0 @@
-import { Formation } from './formation'
-import { validateUUID } from '../utils'
-import { Name } from '../player'
-import { Country } from '../country'
-
-export interface CoachOpts {
-  readonly id: string
-  readonly name: Name
-  readonly country: Country
-  readonly formation?: Formation
-  readonly substitutionTolerance?: number
-}
-
-export class Coach {
-  readonly id: string
-  readonly name: Name
-  readonly country: Country
-  readonly formation?: Formation
-  readonly substitutionTolerance?: number
-
-  constructor ({ id, name, country, formation, substitutionTolerance }: CoachOpts) {
-    validateUUID(id)
-
-    this.id = id
-    this.name = name
-    this.country = country
-    this.formation = formation
-    this.substitutionTolerance = substitutionTolerance
-  }
-}

package/src/service/coach/formation.test.ts

@@ -1,10 +0,0 @@
-import { describe, expect, test } from '@jest/globals'
-
-describe('Formation Test Module', () => {
-  // getFormation Tests
-  test('Should return supported formations', () => {
-    // TODO
-
-    expect(1).toBe(1)
-  })
-})