volleyballsimtypes 0.0.7 → 0.0.8

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

@@ -1,119 +0,0 @@
-import { Rally } from '../rally'
-import { MatchSet } from '../match-set'
-import { MatchTeam } from '../match-team'
-import { team } from '../../team/__stubs__'
-import { libero, rosters } from '../../player/__stubs__'
-import { Match } from '../match'
-import { Team } from '../../team'
-import { coaches } from '../../coach/__stubs__'
-import { country } from '../../country/__stubs__'
-
-export const newRally: Rally = new Rally({
-  servingTeam: team,
-  events: [],
-  order: 1,
-  id: '0ac3ba3a-d710-42dc-a1e7-7066b8df5fd9',
-  homePlayerPosition: [],
-  awayPlayerPosition: []
-})
-
-export const newSet: MatchSet = new MatchSet({
-  id: 'bf337ec2-9fee-495e-8d5a-d834b307d537',
-  stats: [],
-  rallies: [],
-  order: 0,
-  homeScore: 0,
-  awayScore: 0,
-  isTieBreak: false,
-  homeLibero: libero,
-  awayLibero: libero
-})
-
-export const finishedSet: MatchSet = (() => {
-  const set = new MatchSet({
-    id: 'c959fcf6-873f-4eae-80aa-a820e25329c4',
-    stats: [],
-    rallies: [],
-    order: 0,
-    homeScore: 0,
-    awayScore: 0,
-    isTieBreak: false,
-    homeLibero: libero,
-    awayLibero: libero
-  })
-  set.nextState()
-  for (let i = 0; i < 25; i++) {
-    set.increaseScore(MatchTeam.HOME)
-  }
-  set.nextState()
-  return set
-})()
-export const inProgressSet: MatchSet = (() => {
-  const set = new MatchSet({
-    id: 'c1095b6c-9e70-4f9d-9942-d54aaa8655d0',
-    stats: [],
-    rallies: [],
-    order: 0,
-    homeScore: 0,
-    awayScore: 0,
-    isTieBreak: false,
-    homeLibero: libero,
-    awayLibero: libero
-  })
-  set.nextState()
-  for (let i = 0; i < 20; i++) {
-    set.increaseScore(MatchTeam.AWAY)
-  }
-  return set
-})()
-
-export const teams: Team[] = [
-  new Team({
-    id: '334ca929-6e71-4011-a2f0-5ca4fa83dbe5',
-    name: 'Jaloo',
-    shortName: 'JAL',
-    country,
-    roster: rosters[0],
-    coach: coaches[0]
-  }),
-  new Team({
-    id: 'f244d62d-f0ec-4005-8eb2-d955b0b8b191',
-    name: 'Fatz',
-    shortName: 'FAT',
-    country,
-    roster: rosters[1],
-    coach: coaches[1]
-  }),
-  new Team({
-    id: '749a5755-5c8b-4b07-aca9-1365a26c9a2e',
-    name: 'Tagtune',
-    shortName: 'TAG',
-    country,
-    roster: rosters[2],
-    coach: coaches[2]
-  }),
-  new Team({
-    id: 'd3dd532d-4898-44a3-853f-25f6fbdb3534',
-    name: 'Gigabox',
-    shortName: 'GIG',
-    country,
-    roster: rosters[3],
-    coach: coaches[3]
-  })
-]
-
-export const match: Match = new Match({
-  id: '59aa2ea0-cf71-4081-b817-48dfdd454841',
-  homeTeam: teams[0],
-  awayTeam: teams[1],
-  sets: [],
-  scheduledDate: new Date('2023-07-26T21:48:12.273Z')
-})
-
-export const match2: Match = new Match({
-  id: 'dfd87bdc-20c2-4383-92ea-b5c36a8ba7aa',
-  homeTeam: teams[2],
-  awayTeam: teams[3],
-  sets: [],
-  scheduledDate: new Date('2023-07-26T21:48:12.273Z')
-})

package/src/service/match/court-position.test.ts

@@ -1,73 +0,0 @@
-import { describe, expect, test } from '@jest/globals'
-import { CourtPosition, CourtRow } from './court-position'
-
-describe('CourtPosition Test Module', () => {
-  const positions: CourtPosition[] = [CourtPosition.LEFT_BACK, CourtPosition.MIDDLE_BACK, CourtPosition.RIGHT_BACK,
-    CourtPosition.LEFT_FRONT, CourtPosition.MIDDLE_FRONT, CourtPosition.RIGHT_FRONT]
-
-  // getPositions Tests
-  test('Should get all positions', () => {
-    expect(CourtPosition.getPositions()).toEqual(positions)
-  })
-  // rotatePosition Tests
-  test('Should return correct positions for rotation', () => {
-    expect(CourtPosition.rotatePosition(1)).toEqual(CourtPosition.MIDDLE_BACK)
-    expect(CourtPosition.rotatePosition(2)).toEqual(CourtPosition.RIGHT_BACK)
-    expect(CourtPosition.rotatePosition(3)).toEqual(CourtPosition.RIGHT_FRONT)
-    expect(CourtPosition.rotatePosition(4)).toEqual(CourtPosition.MIDDLE_FRONT)
-    expect(CourtPosition.rotatePosition(5)).toEqual(CourtPosition.LEFT_FRONT)
-    expect(CourtPosition.rotatePosition(6)).toEqual(CourtPosition.LEFT_BACK)
-  })
-  test('Should throw Error when rotating an invalid position', () => {
-    function rotate (): void { CourtPosition.rotatePosition(0) }
-
-    expect(rotate).toThrow(/^POSITION_INDEX_OUT_OF_BOUNDS$/)
-  })
-  // isFrontRow Tests
-  test('Should return true for front-row positions', () => {
-    expect(CourtPosition.isFrontRow(CourtPosition.LEFT_FRONT)).toEqual(true)
-    expect(CourtPosition.isFrontRow(CourtPosition.MIDDLE_FRONT)).toEqual(true)
-    expect(CourtPosition.isFrontRow(CourtPosition.RIGHT_FRONT)).toEqual(true)
-  })
-  test('Should return false for back-row positions', () => {
-    expect(CourtPosition.isFrontRow(CourtPosition.LEFT_BACK)).toEqual(false)
-    expect(CourtPosition.isFrontRow(CourtPosition.MIDDLE_BACK)).toEqual(false)
-    expect(CourtPosition.isFrontRow(CourtPosition.RIGHT_BACK)).toEqual(false)
-  })
-  test('Should throw Error providing an invalid position', () => {
-    function front (): void { CourtPosition.isFrontRow(0) }
-
-    expect(front).toThrow(/^POSITION_INDEX_OUT_OF_BOUNDS$/)
-  })
-  // isBackRow Tests
-  test('Should return true for back-row positions', () => {
-    expect(CourtPosition.isBackRow(CourtPosition.LEFT_BACK)).toEqual(true)
-    expect(CourtPosition.isBackRow(CourtPosition.MIDDLE_BACK)).toEqual(true)
-    expect(CourtPosition.isBackRow(CourtPosition.RIGHT_BACK)).toEqual(true)
-  })
-  test('Should return false for front-row positions', () => {
-    expect(CourtPosition.isBackRow(CourtPosition.LEFT_FRONT)).toEqual(false)
-    expect(CourtPosition.isBackRow(CourtPosition.MIDDLE_FRONT)).toEqual(false)
-    expect(CourtPosition.isBackRow(CourtPosition.RIGHT_FRONT)).toEqual(false)
-  })
-  test('Should throw Error providing an invalid position', () => {
-    function back (): void { CourtPosition.isBackRow(0) }
-
-    expect(back).toThrow(/^POSITION_INDEX_OUT_OF_BOUNDS: 0$/)
-  })
-  // getRow Tests
-  test('Should get all front-row positions', () => {
-    expect(CourtPosition.getRow(CourtRow.FRONT))
-      .toEqual([CourtPosition.LEFT_FRONT, CourtPosition.MIDDLE_FRONT, CourtPosition.RIGHT_FRONT])
-  })
-  test('Should get all back-row positions', () => {
-    expect(CourtPosition.getRow(CourtRow.BACK))
-      .toEqual([CourtPosition.LEFT_BACK, CourtPosition.MIDDLE_BACK, CourtPosition.RIGHT_BACK])
-  })
-  test('Should throw Error providing an invalid row', () => {
-    // @ts-expect-error
-    function row (): void { CourtPosition.getRow(CourtRow.FAKE) }
-
-    expect(row).toThrow(/^INVALID_ROW: undefined$/)
-  })
-})

package/src/service/match/court-position.ts

@@ -1,46 +0,0 @@
-export enum CourtRow {
-  BACK = 'BACK_ROW',
-  FRONT = 'FRONT_ROW'
-}
-
-export enum CourtPosition {
-  NOT_IN_COURT = -1, LIBERO_ZONE = 0,
-  // -----------------------------------------------------
-  LEFT_FRONT = 4, MIDDLE_FRONT = 3, RIGHT_FRONT = 2,
-  LEFT_BACK = 5, MIDDLE_BACK = 6, RIGHT_BACK = 1
-}
-
-// eslint-disable-next-line @typescript-eslint/no-namespace
-export namespace CourtPosition {
-  const FRONT_ROW = [CourtPosition.LEFT_FRONT, CourtPosition.MIDDLE_FRONT, CourtPosition.RIGHT_FRONT]
-  const BACK_ROW = [CourtPosition.LEFT_BACK, CourtPosition.MIDDLE_BACK, CourtPosition.RIGHT_BACK]
-
-  export function getPositions (): CourtPosition[] {
-    return [...BACK_ROW, ...FRONT_ROW]
-  }
-
-  export function rotatePosition (position: number): CourtPosition {
-    if (position < 1 || position > 6) throw new Error('POSITION_INDEX_OUT_OF_BOUNDS')
-
-    if (position > CourtPosition.RIGHT_BACK) return position - 1
-    else return CourtPosition.MIDDLE_BACK
-  }
-
-  export function isFrontRow (position: number): boolean {
-    if (position < 1 || position > 6) throw new Error('POSITION_INDEX_OUT_OF_BOUNDS')
-
-    return FRONT_ROW.includes(position)
-  }
-
-  export function isBackRow (position: number): boolean {
-    if (position < 1 || position > 6) throw new Error(`POSITION_INDEX_OUT_OF_BOUNDS: ${position}`)
-
-    return BACK_ROW.includes(position)
-  }
-
-  export function getRow (row: CourtRow): CourtPosition[] {
-    if (![CourtRow.BACK, CourtRow.FRONT].includes(row)) throw new Error(`INVALID_ROW: ${row}`)
-
-    return CourtRow.BACK === row ? [...BACK_ROW] : [...FRONT_ROW]
-  }
-}

package/src/service/match/court-target.test.ts

@@ -1,39 +0,0 @@
-import { describe, expect, test } from '@jest/globals'
-import { CourtTarget } from './court-target'
-
-describe('CourtTarget Test Module', () => {
-  // getSidePosition Tests
-  test('Should get correct court position', () => {
-    for (let i = 1; i < 7; i++) {
-      expect(CourtTarget.getSidePosition(i)).toBe(i)
-      expect(CourtTarget.getSidePosition(i + 6)).toBe(i)
-    }
-  })
-  test('Should throw Error when position is out of bounds', () => {
-    function position (): void { CourtTarget.getSidePosition(0) }
-
-    expect(position).toThrow(/^POSITION_INDEX_OUT_OF_BOUNDS$/)
-  })
-  // getTeamSide Tests
-  test('Should return team positions', () => {
-    const positions: CourtTarget[] = CourtTarget.getTeamSide()
-
-    expect(positions[0]).toBe(CourtTarget.TEAM_RIGHT_BACK)
-    expect(positions[1]).toBe(CourtTarget.TEAM_RIGHT_FRONT)
-    expect(positions[2]).toBe(CourtTarget.TEAM_MIDDLE_FRONT)
-    expect(positions[3]).toBe(CourtTarget.TEAM_LEFT_FRONT)
-    expect(positions[4]).toBe(CourtTarget.TEAM_LEFT_BACK)
-    expect(positions[5]).toBe(CourtTarget.TEAM_MIDDLE_BACK)
-  })
-  // getOpponentSide Tests
-  test('Should return opponent team positions', () => {
-    const positions: CourtTarget[] = CourtTarget.getOpponentSide()
-
-    expect(positions[0]).toBe(CourtTarget.OPPONENT_RIGHT_BACK)
-    expect(positions[1]).toBe(CourtTarget.OPPONENT_RIGHT_FRONT)
-    expect(positions[2]).toBe(CourtTarget.OPPONENT_MIDDLE_FRONT)
-    expect(positions[3]).toBe(CourtTarget.OPPONENT_LEFT_FRONT)
-    expect(positions[4]).toBe(CourtTarget.OPPONENT_LEFT_BACK)
-    expect(positions[5]).toBe(CourtTarget.OPPONENT_MIDDLE_BACK)
-  })
-})

package/src/service/match/court-target.ts

@@ -1,30 +0,0 @@
-import { CourtPosition } from './court-position'
-
-export enum CourtTarget {
-  NO_TARGET = 0,
-  OPPONENT_RIGHT_BACK = 7, OPPONENT_MIDDLE_BACK = 12, OPPONENT_LEFT_BACK = 11,
-  OPPONENT_RIGHT_FRONT = 8, OPPONENT_MIDDLE_FRONT = 9, OPPONENT_LEFT_FRONT = 10,
-  // --------------------------------------------------------------------------------
-  TEAM_LEFT_FRONT = 4, TEAM_MIDDLE_FRONT = 3, TEAM_RIGHT_FRONT = 2,
-  TEAM_LEFT_BACK = 5, TEAM_MIDDLE_BACK = 6, TEAM_RIGHT_BACK = 1,
-}
-
-// eslint-disable-next-line @typescript-eslint/no-namespace
-export namespace CourtTarget {
-  export function getTeamSide (): CourtTarget[] {
-    return [CourtTarget.TEAM_RIGHT_BACK, CourtTarget.TEAM_RIGHT_FRONT, CourtTarget.TEAM_MIDDLE_FRONT,
-      CourtTarget.TEAM_LEFT_FRONT, CourtTarget.TEAM_LEFT_BACK, CourtTarget.TEAM_MIDDLE_BACK]
-  }
-
-  export function getOpponentSide (): CourtTarget[] {
-    return [CourtTarget.OPPONENT_RIGHT_BACK, CourtTarget.OPPONENT_RIGHT_FRONT, CourtTarget.OPPONENT_MIDDLE_FRONT,
-      CourtTarget.OPPONENT_LEFT_FRONT, CourtTarget.OPPONENT_LEFT_BACK, CourtTarget.OPPONENT_MIDDLE_BACK]
-  }
-
-  export function getSidePosition (position: number): CourtPosition {
-    if (position < 1 || position > 12) throw new Error('POSITION_INDEX_OUT_OF_BOUNDS')
-
-    if (position > 6) return position - 6
-    else return position
-  }
-}

package/src/service/match/index.ts

@@ -1,6 +0,0 @@
-export * from './match'
-export * from './match-set'
-export * from './rally'
-export * from './court-position'
-export * from './court-target'
-export * from './match-team'

package/src/service/match/match-set.test.ts

@@ -1,174 +0,0 @@
-import { describe, expect, test } from '@jest/globals'
-import { MatchSet, MatchSetState } from './match-set'
-import { MatchTeam } from './match-team'
-import { newRally } from './__stubs__'
-import { libero } from '../player/__stubs__'
-
-describe('MatchSet Test Module', () => {
-  let set: MatchSet
-  let tieBreakSet: MatchSet
-
-  beforeEach(() => {
-    set = new MatchSet({
-      id: '4a8d1149-0157-461c-afb4-8a2d9776da5a',
-      rallies: [],
-      stats: [],
-      awayScore: 0,
-      homeScore: 0,
-      order: 0,
-      isTieBreak: false,
-      homeLibero: libero,
-      awayLibero: libero
-    })
-    tieBreakSet = new MatchSet({
-      id: '5fed79c1-1146-45fb-acdd-acd4eb99bda3',
-      rallies: [],
-      stats: [],
-      awayScore: 0,
-      homeScore: 0,
-      order: 0,
-      isTieBreak: true,
-      homeLibero: libero,
-      awayLibero: libero
-    })
-  })
-
-  test('Should instantiate object properly', () => {
-    expect(set.id).toBe('4a8d1149-0157-461c-afb4-8a2d9776da5a')
-    expect(set.rallies.length).toBe(0)
-    expect(set.state).toBe(0)
-    expect(set.getHomeScore()).toBe(0)
-    expect(set.getAwayScore()).toBe(0)
-  })
-  // increaseScore Tests
-  test('Should increase score of home team', () => {
-    set.nextState()
-    expect(set.getHomeScore).toBe(0)
-    set.increaseScore(MatchTeam.HOME)
-    expect(set.getHomeScore).toBe(1)
-  })
-  test('Should increase score of away team', () => {
-    set.nextState()
-    expect(set.getAwayScore).toBe(0)
-    set.increaseScore(MatchTeam.AWAY)
-    expect(set.getAwayScore).toBe(1)
-  })
-  test('Should throw Error when trying to increase score of finished set', () => {
-    set.nextState()
-    for (let i = 0; i < 25; i++) set.increaseScore(MatchTeam.HOME)
-
-    function fin1 (): void { set.increaseScore(MatchTeam.HOME) }
-
-    function fin2 (): void { tieBreakSet.increaseScore(MatchTeam.HOME) }
-
-    expect(fin1).toThrow(/^CANNOT_INCREASE_SCORE_OF_SET$/)
-    expect(fin2).toThrow(/^CANNOT_INCREASE_SCORE_OF_SET$/)
-  })
-  test('Should throw Error when providing invalid team', () => {
-    set.nextState()
-
-    // @ts-expect-error
-    function fin (): void { set.increaseScore(MatchTeam.OTHER) }
-
-    expect(fin).toThrow(/^UNKNOWN_TEAM$/)
-  })
-  // addRally Tests
-  test('Should rally to rally array', () => {
-    expect(set.rallies.length).toBe(0)
-    set.addRally(newRally)
-    expect(set.rallies.length).toBe(1)
-  })
-  // isOver Tests
-  test('Should return true for team reaching point threshold', () => {
-    set.nextState()
-    expect(set.isOver()).toBe(false)
-
-    for (let i = 0; i < 25; i++) set.increaseScore(MatchTeam.HOME)
-
-    expect(set.isOver()).toBe(true)
-  })
-  test('Should return true for both teams reaching point threshold and point difference greater than 1',
-    () => {
-      set.nextState()
-
-      for (let i = 0; i < 25; i++) {
-        set.increaseScore(MatchTeam.HOME)
-        set.increaseScore(MatchTeam.AWAY)
-      }
-
-      expect(set.isOver()).toBe(false)
-      set.increaseScore(MatchTeam.HOME)
-      expect(set.isOver()).toBe(false)
-      set.increaseScore(MatchTeam.HOME)
-      expect(set.isOver()).toBe(true)
-    })
-  // nextState Tests
-  test('Should advance to in play', () => {
-    expect(set.state).toBe(0)
-    set.nextState()
-    expect(set.state).toBe(1)
-  })
-  test('Should throw Error if in play and set not over', () => {
-    set.nextState()
-
-    function fin (): void { set.nextState() }
-
-    expect(fin).toThrow(/^CANNOT_ADVANCE_SET_STATE$/)
-  })
-  test('Should advance to FINISHED if set is over', () => {
-    set.nextState()
-
-    for (let i = 0; i < 25; i++) set.increaseScore(MatchTeam.HOME)
-
-    set.nextState()
-    expect(set.state).toBe(2)
-  })
-  test('Should throw Error when trying to transition from FINISHED state', () => {
-    set.nextState()
-
-    for (let i = 0; i < 25; i++) set.increaseScore(MatchTeam.HOME)
-
-    set.nextState()
-
-    function fin (): void { set.nextState() }
-
-    expect(fin).toThrow(/^CANT_GET_STATE_AFTER: FINISHED$/)
-  })
-  // getWinner Tests
-  test('Should throw Error when getting winner of unfinished set', () => {
-    function fin (): void { set.getWinner() }
-
-    expect(fin).toThrow(/^UNFINISHED_SET$/)
-  })
-  test('Should get correct set winner', () => {
-    set.nextState()
-
-    for (let i = 0; i < 25; i++) set.increaseScore(MatchTeam.HOME)
-
-    expect(set.getWinner()).toBe(MatchTeam.HOME)
-
-    tieBreakSet.nextState()
-
-    for (let i = 0; i < 15; i++) tieBreakSet.increaseScore(MatchTeam.AWAY)
-
-    expect(tieBreakSet.getWinner()).toBe(MatchTeam.AWAY)
-  })
-  // MatchSetState Tests
-  test('Should get next state', () => {
-    expect(MatchSetState.nextState(0)).toBe(1)
-    expect(MatchSetState.nextState(1)).toBe(2)
-  })
-  test('Should throw Error for state outside range', () => {
-    function fn1 (): void { MatchSetState.nextState(-1) }
-
-    function fn2 (): void { MatchSetState.nextState(3) }
-
-    expect(fn1).toThrow(/^STATE_INDEX_OUT_OF_BOUNDS$/)
-    expect(fn2).toThrow(/^STATE_INDEX_OUT_OF_BOUNDS$/)
-  })
-  test('Should throw Error for last state', () => {
-    function fn (): void { MatchSetState.nextState(2) }
-
-    expect(fn).toThrow(/^CANT_GET_STATE_AFTER: FINISHED$/)
-  })
-})

package/src/service/match/match-set.ts

@@ -1,140 +0,0 @@
-import { Rally } from './rally'
-import { validateUUID } from '../utils'
-import { MatchTeam } from './match-team'
-import { Player } from '../player'
-
-export enum MatchSetState {
-  NEW = 0,
-  IN_PLAY = 1,
-  FINISHED = 2
-}
-
-// eslint-disable-next-line @typescript-eslint/no-namespace
-export namespace MatchSetState {
-  export function nextState (state: number): MatchSetState {
-    if (state < 0 || state > 2) throw new Error('STATE_INDEX_OUT_OF_BOUNDS')
-    if (state === 2) throw new Error(`CANT_GET_STATE_AFTER: ${MatchSetState[state]}`)
-
-    return state + 1
-  }
-}
-
-enum ScoreThreshold {
-  SET = 25,
-  TIE_BREAK = 15
-}
-
-export interface MatchSetOpts {
-  readonly id: string
-  readonly order: number
-  readonly isTieBreak: boolean
-  readonly homeLibero: Player | undefined
-  readonly awayLibero: Player | undefined
-  readonly homeScore: number
-  readonly awayScore: number
-  readonly stats: SetStatistics[]
-  readonly rallies: Rally[]
-}
-
-export interface EventStat {
-  success: number
-  error: number
-}
-
-export interface SetStatistics {
-  player: Player
-  ace: number
-  attempts: number
-  contacts: number
-  ralliesPlayed: number
-  serve: EventStat
-  reception: EventStat
-  set: EventStat
-  attack: EventStat
-  block: EventStat
-  kills: number
-  killBlocks: number
-  assists: number
-}
-
-export class MatchSet {
-  readonly id: string
-  readonly order: number
-  readonly isTieBreak: boolean
-  readonly homeLibero: Player | undefined
-  readonly awayLibero: Player | undefined
-  private readonly scoreThreshold: ScoreThreshold
-  private homeScore: number
-  private awayScore: number
-  readonly stats: SetStatistics[]
-  readonly rallies: Rally[]
-
-  constructor ({ id, order, isTieBreak, homeLibero, awayLibero, stats, rallies, homeScore, awayScore }: MatchSetOpts) {
-    validateUUID(id)
-
-    this.id = id
-    this.order = order
-    this.homeScore = homeScore
-    this.awayScore = awayScore
-    this.homeLibero = homeLibero
-    this.awayLibero = awayLibero
-    this.stats = stats
-    this.rallies = rallies
-    this.isTieBreak = isTieBreak
-    this.scoreThreshold = isTieBreak ? ScoreThreshold.TIE_BREAK : ScoreThreshold.SET
-    this._state = MatchSetState.NEW
-  }
-
-  public getHomeScore (): number {
-    return this.homeScore
-  }
-
-  public getAwayScore (): number {
-    return this.awayScore
-  }
-
-  private _state: MatchSetState
-
-  get state (): MatchSetState {
-    return this._state
-  }
-
-  public increaseScore (team: MatchTeam): void {
-    if (this._state !== MatchSetState.IN_PLAY || this.isOver()) throw new Error('CANNOT_INCREASE_SCORE_OF_SET')
-
-    if (team === MatchTeam.HOME) this.homeScore++
-    else if (team === MatchTeam.AWAY) this.awayScore++
-    else throw new Error('UNKNOWN_TEAM')
-  }
-
-  public addRally (rally: Rally): void {
-    this.rallies.push(rally)
-  }
-
-  /**
-   * Has a team reached at least 25 points and is the score difference between both teams at least 2?
-   * @returns boolean
-   */
-  public isOver (): boolean {
-    return Math.abs(this.homeScore - this.awayScore) > 1 &&
-      (this.homeScore >= this.scoreThreshold || this.awayScore >= this.scoreThreshold)
-  }
-
-  public nextState (): void {
-    if (this._state === 1 && !this.isOver()) {
-      throw new Error('CANNOT_ADVANCE_SET_STATE')
-    }
-
-    this._state = MatchSetState.nextState(this._state)
-  }
-
-  /**
-   * Get the team that won the Set. Return undefined if set is not over.
-   * @returns CourtTeam
-   */
-  public getWinner (): MatchTeam {
-    if (!this.isOver()) throw new Error('UNFINISHED_SET')
-
-    return this.homeScore > this.awayScore ? MatchTeam.HOME : MatchTeam.AWAY
-  }
-}

package/src/service/match/match-team.test.ts

@@ -1,16 +0,0 @@
-import { describe, expect, test } from '@jest/globals'
-import { MatchTeam } from './match-team'
-
-describe('MatchTeam Test Module', () => {
-  // otherTeam Tests
-  test('Should return correct team string', () => {
-    expect(MatchTeam.otherTeam(MatchTeam.AWAY)).toBe(MatchTeam.HOME)
-    expect(MatchTeam.otherTeam(MatchTeam.HOME)).toBe(MatchTeam.AWAY)
-  })
-  test('Should throw Error when providing invalid MatchTeam', () => {
-    // @ts-expect-error
-    function team (): void { MatchTeam.otherTeam(MatchTeam.OTHER) }
-
-    expect(team).toThrow(/^UNKNOWN_MATCH_TEAM$/)
-  })
-})

package/src/service/match/match-team.ts

@@ -1,13 +0,0 @@
-export enum MatchTeam {
-  HOME = 'homeTeam',
-  AWAY = 'awayTeam'
-}
-
-// eslint-disable-next-line @typescript-eslint/no-namespace
-export namespace MatchTeam {
-  export function otherTeam (team: MatchTeam): MatchTeam {
-    if (team === MatchTeam.HOME) return MatchTeam.AWAY
-    else if (team === MatchTeam.AWAY) return MatchTeam.HOME
-    else throw new Error('UNKNOWN_MATCH_TEAM')
-  }
-}