volleyballsimtypes 0.0.1

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

@@ -0,0 +1,119 @@
+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

@@ -0,0 +1,73 @@
+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

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,174 @@
+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

@@ -0,0 +1,140 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,13 @@
+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')
+  }
+}