volleyballsimtypes 0.0.217 → 0.0.358

package/dist/esm/src/service/match/match-generator.js

@@ -0,0 +1,67 @@
+import dayjs from 'dayjs';
+import { v4 as uuidv4 } from 'uuid';
+import { Match } from './match';
+import { shuffle } from '../utils';
+import { StatusEnum } from '../../data';
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+export default class MatchGenerator {
+    static generateMatches(teams, baseDate) {
+        const t = new Set(teams.map(x => x.id));
+        let date = dayjs(baseDate).startOf('hour');
+        if (t.size !== teams.length) {
+            throw new Error('DUPLICATE_TEAMS');
+        }
+        let shuffled = shuffle([...teams]);
+        const l = shuffled.length - 1;
+        const half = Math.ceil(shuffled.length / 2);
+        const matches = [];
+        // We fix the first team
+        let firstTeam = shuffled.shift();
+        if (firstTeam == null) {
+            throw new Error('EMPTY_TEAM_ARRAY');
+        }
+        let homeRow;
+        let awayRow;
+        for (let i = 0; i < l; i++) {
+            // split array in 2 halves
+            const row1 = shuffled.slice(0, half);
+            const row2 = shuffled.slice(half);
+            row2.push(firstTeam);
+            if (i % 2 === 0) {
+                homeRow = row1;
+                awayRow = row2;
+            }
+            else {
+                homeRow = row2;
+                awayRow = row1;
+            }
+            for (let j = 0; j < half; j++) {
+                matches.push(Match.create({
+                    id: uuidv4(),
+                    homeTeam: homeRow[j],
+                    awayTeam: awayRow[j],
+                    scheduledDate: date.toDate(),
+                    status: StatusEnum.PENDING
+                }));
+                date = date.add(30, 'minutes');
+            }
+            firstTeam = row2.pop();
+            row1.unshift(row2.shift());
+            row2.push(row1.pop());
+            shuffled = [...row1, ...row2];
+        }
+        // Generate Inverted matches for home-away pairings
+        matches.push(...matches.map(match => {
+            const scheduledDate = date.toDate();
+            date = date.add(30, 'minutes');
+            return Match.create({
+                id: uuidv4(),
+                homeTeam: match.awayTeam,
+                awayTeam: match.homeTeam,
+                scheduledDate,
+                status: StatusEnum.PENDING
+            });
+        }));
+        return matches;
+    }
+}

package/dist/esm/src/service/match/match-rating.d.ts

@@ -1,35 +1,34 @@
-import { Match, MatchTeam } from '.';
-import { CompetitionType } from '../../data';
-interface MatchRatingParams {
-    readonly match: Match;
-    readonly competitionType: CompetitionType;
-}
-interface SetScoreVariant {
-    '3-0': number;
-    '3-1': number;
-    '3-2': number;
-    '2-3': number;
-    '1-3': number;
-    '0-3': number;
-}
-interface MatchWeightFactor {
-    TOURNAMENT: number;
-    LEAGUE: number;
-}
-export declare class MatchRating {
-    static K: number;
-    static SSV: SetScoreVariant;
-    static C1: number;
-    static C2: number;
-    static C3: number;
-    static C4: number;
-    static C5: number;
-    static MWF: MatchWeightFactor;
-    readonly match: Match;
-    readonly weight: number;
-    constructor({ match, competitionType }: MatchRatingParams);
-    getPoints(team: MatchTeam): number;
-    static calculateProbability(z: number): number;
-    getExpectedResult(): number;
-}
-export {};
+import { Match, MatchTeam } from '.';
+import { MatchContext } from './schemas/match-rating.z';
+export type { MatchContext };
+interface SetScoreVariant {
+    '3-0': number;
+    '3-1': number;
+    '3-2': number;
+    '2-3': number;
+    '1-3': number;
+    '0-3': number;
+}
+export declare class MatchRating {
+    static readonly K: number;
+    static readonly C1: number;
+    static readonly C2: number;
+    static readonly C3: number;
+    static readonly C4: number;
+    static readonly C5: number;
+    static readonly SSV: SetScoreVariant;
+    static readonly LEAGUE_BASE: number;
+    static readonly TIER_PENALTY: number;
+    static readonly QUALIFIER_WEIGHT: number;
+    static readonly TOURNAMENT_WEIGHT: number;
+    readonly match: Match;
+    readonly weight: number;
+    static create(input: unknown): MatchRating;
+    private constructor();
+    private static leagueWeight;
+    private static applyBotPenalty;
+    private static computeWeight;
+    static calculateProbability(z: number): number;
+    getExpectedResult(): number;
+    getPoints(team: MatchTeam): number;
+}

package/dist/esm/src/service/match/match-rating.js

@@ -1,55 +1,93 @@
-import { MatchTeam } from '.';
-import { erf } from '../utils';
-export class MatchRating {
-    constructor({ match, competitionType }) {
-        this.match = match;
-        this.weight = MatchRating.MWF[competitionType];
-    }
-    getPoints(team) {
-        const homeScoreKey = this.match.getScore();
-        const emr = this.getExpectedResult();
-        const ssv = MatchRating.SSV[homeScoreKey];
-        const homeDelta = (ssv - emr) * this.weight / MatchRating.K;
-        return team === MatchTeam.HOME ? homeDelta : -homeDelta;
-    }
-    static calculateProbability(z) {
-        return 0.5 * (1 + erf(z / Math.SQRT2));
-    }
-    getExpectedResult() {
-        const D = MatchRating.K * (this.match.homeTeam.rating - this.match.awayTeam.rating) / 1000; // Strength difference between the teams
-        const P1 = MatchRating.calculateProbability(MatchRating.C1 + D); // 3-0
-        const P2 = MatchRating.calculateProbability(MatchRating.C2 + D) -
-            MatchRating.calculateProbability(MatchRating.C1 + D); // 3-1
-        const P3 = MatchRating.calculateProbability(MatchRating.C3 + D) -
-            MatchRating.calculateProbability(MatchRating.C2 + D); // 3-2
-        const P4 = MatchRating.calculateProbability(MatchRating.C4 + D) -
-            MatchRating.calculateProbability(MatchRating.C3 + D); // 2-3
-        const P5 = MatchRating.calculateProbability(MatchRating.C5 + D) -
-            MatchRating.calculateProbability(MatchRating.C4 + D); // 1-3
-        const P6 = 1 - MatchRating.calculateProbability(MatchRating.C5 + D); // 0-3
-        return P1 * MatchRating.SSV['3-0'] +
-            P2 * MatchRating.SSV['3-1'] +
-            P3 * MatchRating.SSV['3-2'] +
-            P4 * MatchRating.SSV['2-3'] +
-            P5 * MatchRating.SSV['1-3'] +
-            P6 * MatchRating.SSV['0-3']; // Expected Match Result EMR
-    }
-}
-MatchRating.K = 8; // Standard scaling factor
-MatchRating.SSV = {
-    '3-0': 2,
-    '3-1': 1.5,
-    '3-2': 1,
-    '2-3': -1,
-    '1-3': -1.5,
-    '0-3': -2
-};
-MatchRating.C1 = -1.060;
-MatchRating.C2 = -0.394;
-MatchRating.C3 = 0;
-MatchRating.C4 = 0.394;
-MatchRating.C5 = 1.060;
-MatchRating.MWF = {
-    TOURNAMENT: 50,
-    LEAGUE: 35
-};
+import { MatchTeam } from '.';
+import { erf } from '../utils';
+import { MatchRatingInputSchema } from './schemas/match-rating.z';
+export class MatchRating {
+    static create(input) {
+        const result = MatchRatingInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_MATCH_RATING: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new MatchRating(result.data);
+    }
+    constructor({ match, context }) {
+        this.match = match;
+        this.weight = MatchRating.computeWeight(context);
+    }
+    static leagueWeight(tier) {
+        return Math.max(MatchRating.TIER_PENALTY, MatchRating.LEAGUE_BASE - MatchRating.TIER_PENALTY * tier);
+    }
+    static applyBotPenalty(weight, homeIsBot, awayIsBot) {
+        const bots = (homeIsBot ? 1 : 0) + (awayIsBot ? 1 : 0);
+        return weight * Math.pow(0.5, bots);
+    }
+    static computeWeight(context) {
+        switch (context.kind) {
+            case 'LEAGUE': {
+                const base = MatchRating.leagueWeight(context.tier);
+                return MatchRating.applyBotPenalty(base, context.homeIsBot, context.awayIsBot);
+            }
+            case 'PROMOTION': {
+                const base = (MatchRating.leagueWeight(context.upperTier) + MatchRating.leagueWeight(context.lowerTier)) / 2;
+                return MatchRating.applyBotPenalty(base, context.homeIsBot, context.awayIsBot);
+            }
+            case 'QUALIFIER':
+                return MatchRating.applyBotPenalty(MatchRating.QUALIFIER_WEIGHT, context.homeIsBot, context.awayIsBot);
+            case 'TOURNAMENT':
+                return MatchRating.applyBotPenalty(MatchRating.TOURNAMENT_WEIGHT, context.homeIsBot, context.awayIsBot);
+        }
+    }
+    static calculateProbability(z) {
+        return 0.5 * (1 + erf(z / Math.SQRT2));
+    }
+    getExpectedResult() {
+        const D = MatchRating.K * (this.match.homeTeam.rating - this.match.awayTeam.rating) / 1000;
+        const P1 = MatchRating.calculateProbability(MatchRating.C1 + D);
+        const P2 = MatchRating.calculateProbability(MatchRating.C2 + D) - MatchRating.calculateProbability(MatchRating.C1 + D);
+        const P3 = MatchRating.calculateProbability(MatchRating.C3 + D) - MatchRating.calculateProbability(MatchRating.C2 + D);
+        const P4 = MatchRating.calculateProbability(MatchRating.C4 + D) - MatchRating.calculateProbability(MatchRating.C3 + D);
+        const P5 = MatchRating.calculateProbability(MatchRating.C5 + D) - MatchRating.calculateProbability(MatchRating.C4 + D);
+        const P6 = 1 - MatchRating.calculateProbability(MatchRating.C5 + D);
+        return P1 * MatchRating.SSV['3-0'] +
+            P2 * MatchRating.SSV['3-1'] +
+            P3 * MatchRating.SSV['3-2'] +
+            P4 * MatchRating.SSV['2-3'] +
+            P5 * MatchRating.SSV['1-3'] +
+            P6 * MatchRating.SSV['0-3'];
+    }
+    getPoints(team) {
+        const homeScoreKey = this.match.getScore();
+        const emr = this.getExpectedResult();
+        const ssv = MatchRating.SSV[homeScoreKey];
+        const homeDelta = (ssv - emr) * this.weight / MatchRating.K;
+        return team === MatchTeam.HOME ? homeDelta : -homeDelta;
+    }
+}
+// Standard scaling factor (FIVB spec)
+MatchRating.K = 8;
+// Cut-points for the normal distribution (symmetric, equal-strength baseline)
+MatchRating.C1 = -1.060;
+MatchRating.C2 = -0.394;
+MatchRating.C3 = 0;
+MatchRating.C4 = 0.394;
+MatchRating.C5 = 1.060;
+MatchRating.SSV = {
+    '3-0': 2,
+    '3-1': 1.5,
+    '3-2': 1,
+    '2-3': -1,
+    '1-3': -1.5,
+    '0-3': -2
+};
+// League weight = LEAGUE_BASE - TIER_PENALTY * tier
+// Tier 1 → 35, Tier 2 → 30, Tier 3 → 25, Tier 4 → 20, ...
+MatchRating.LEAGUE_BASE = 40;
+MatchRating.TIER_PENALTY = 5;
+// Regional qualifier — higher prestige than any league tier
+MatchRating.QUALIFIER_WEIGHT = 45;
+// WCC tournament — top of the hierarchy
+MatchRating.TOURNAMENT_WEIGHT = 55;

package/dist/esm/src/service/match/match-rating.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/src/service/match/match-rating.test.js

@@ -0,0 +1,144 @@
+import { describe, it, expect } from '@jest/globals';
+import { MatchRating } from './match-rating';
+import { MatchTeam } from './match-team';
+import { makeTeam, makeMatch30, makeMatch31 } from '../test-helpers';
+import { erf } from '../utils/number-utils';
+// ─── MatchRating.calculateProbability (static normal CDF) ───────────────────
+describe('MatchRating.calculateProbability()', () => {
+    it('returns 0.5 at z = 0 (symmetric distribution)', () => {
+        expect(MatchRating.calculateProbability(0)).toBeCloseTo(0.5, 5);
+    });
+    it('is monotone: P(z1) < P(z2) when z1 < z2', () => {
+        expect(MatchRating.calculateProbability(-1))
+            .toBeLessThan(MatchRating.calculateProbability(0));
+        expect(MatchRating.calculateProbability(0))
+            .toBeLessThan(MatchRating.calculateProbability(1));
+    });
+    it('approaches 1 for large positive z', () => {
+        expect(MatchRating.calculateProbability(10)).toBeCloseTo(1, 5);
+    });
+    it('approaches 0 for large negative z', () => {
+        expect(MatchRating.calculateProbability(-10)).toBeCloseTo(0, 5);
+    });
+    it('matches the formula 0.5 * (1 + erf(z / sqrt(2)))', () => {
+        for (const z of [-2, -1, 0, 1, 2]) {
+            expect(MatchRating.calculateProbability(z))
+                .toBeCloseTo(0.5 * (1 + erf(z / Math.SQRT2)), 8);
+        }
+    });
+});
+// ─── weight computation ───────────────────────────────────────────────────────
+describe('MatchRating weight computation', () => {
+    function makeRating(context) {
+        const home = makeTeam();
+        const away = makeTeam();
+        const match = makeMatch30(home, away);
+        return MatchRating.create({ match, context });
+    }
+    it('LEAGUE tier 1 → weight = LEAGUE_BASE - TIER_PENALTY * 1 = 35', () => {
+        const mr = makeRating({ kind: 'LEAGUE', tier: 1, homeIsBot: false, awayIsBot: false });
+        expect(mr.weight).toBe(35);
+    });
+    it('LEAGUE tier 7 → weight is floored at TIER_PENALTY (5)', () => {
+        // 40 - 5*7 = 5 (minimum is TIER_PENALTY itself)
+        const mr = makeRating({ kind: 'LEAGUE', tier: 7, homeIsBot: false, awayIsBot: false });
+        expect(mr.weight).toBe(5);
+    });
+    it('QUALIFIER → weight = QUALIFIER_WEIGHT (45)', () => {
+        const mr = makeRating({ kind: 'QUALIFIER', homeIsBot: false, awayIsBot: false });
+        expect(mr.weight).toBe(45);
+    });
+    it('TOURNAMENT → weight = TOURNAMENT_WEIGHT (55)', () => {
+        const mr = makeRating({ kind: 'TOURNAMENT', homeIsBot: false, awayIsBot: false });
+        expect(mr.weight).toBe(55);
+    });
+    it('each bot halves the weight', () => {
+        const noBots = makeRating({ kind: 'QUALIFIER', homeIsBot: false, awayIsBot: false });
+        const oneBot = makeRating({ kind: 'QUALIFIER', homeIsBot: true, awayIsBot: false });
+        const twoBots = makeRating({ kind: 'QUALIFIER', homeIsBot: true, awayIsBot: true });
+        expect(oneBot.weight).toBeCloseTo(noBots.weight * 0.5, 10);
+        expect(twoBots.weight).toBeCloseTo(noBots.weight * 0.25, 10);
+    });
+    it('PROMOTION weight is the average of the two league tier weights', () => {
+        // upperTier=1 (35), lowerTier=2 (30) → avg = 32.5
+        const mr = makeRating({ kind: 'PROMOTION', upperTier: 1, lowerTier: 2, homeIsBot: false, awayIsBot: false });
+        expect(mr.weight).toBeCloseTo(32.5, 5);
+    });
+});
+// ─── getExpectedResult ────────────────────────────────────────────────────────
+describe('MatchRating.getExpectedResult()', () => {
+    function makeRatingForTeams(homeRating, awayRating) {
+        const home = makeTeam({ rating: homeRating });
+        const away = makeTeam({ rating: awayRating });
+        const match = makeMatch30(home, away);
+        return MatchRating.create({ match, context: { kind: 'LEAGUE', tier: 1, homeIsBot: false, awayIsBot: false } });
+    }
+    it('returns 0 when both teams have equal rating', () => {
+        const mr = makeRatingForTeams(1000, 1000);
+        expect(mr.getExpectedResult()).toBeCloseTo(0, 5);
+    });
+    it('returns a positive value when home team is stronger', () => {
+        const mr = makeRatingForTeams(1500, 1000);
+        expect(mr.getExpectedResult()).toBeGreaterThan(0);
+    });
+    it('returns a negative value when away team is stronger', () => {
+        const mr = makeRatingForTeams(1000, 1500);
+        expect(mr.getExpectedResult()).toBeLessThan(0);
+    });
+    it('is antisymmetric: EMR(h, a) = -EMR(a, h)', () => {
+        const mr1 = makeRatingForTeams(1200, 800);
+        const mr2 = makeRatingForTeams(800, 1200);
+        expect(mr1.getExpectedResult()).toBeCloseTo(-mr2.getExpectedResult(), 8);
+    });
+});
+// ─── getPoints ────────────────────────────────────────────────────────────────
+describe('MatchRating.getPoints()', () => {
+    it('home and away deltas are opposite signs', () => {
+        const home = makeTeam({ rating: 1000 });
+        const away = makeTeam({ rating: 1000 });
+        const match = makeMatch30(home, away);
+        const mr = MatchRating.create({ match, context: { kind: 'LEAGUE', tier: 1, homeIsBot: false, awayIsBot: false } });
+        expect(mr.getPoints(MatchTeam.HOME)).toBeCloseTo(-mr.getPoints(MatchTeam.AWAY), 10);
+    });
+    it('winning home team gains positive points against equal opponent (3-0)', () => {
+        const home = makeTeam({ rating: 1000 });
+        const away = makeTeam({ rating: 1000 });
+        const match = makeMatch30(home, away);
+        const mr = MatchRating.create({ match, context: { kind: 'LEAGUE', tier: 1, homeIsBot: false, awayIsBot: false } });
+        // ssv['3-0'] = 2, emr = 0 for equal teams → homeDelta = 2 * weight / K > 0
+        expect(mr.getPoints(MatchTeam.HOME)).toBeGreaterThan(0);
+        expect(mr.getPoints(MatchTeam.AWAY)).toBeLessThan(0);
+    });
+    it('match winner earns fewer points when they were heavily favoured', () => {
+        // Strong home team beats weak away — less surprising, fewer points
+        const strongHome = makeTeam({ rating: 2000 });
+        const weakAway = makeTeam({ rating: 500 });
+        const evenHome = makeTeam({ rating: 1000 });
+        const evenAway = makeTeam({ rating: 1000 });
+        const surpriseMr = MatchRating.create({
+            match: makeMatch30(evenHome, evenAway),
+            context: { kind: 'LEAGUE', tier: 1, homeIsBot: false, awayIsBot: false }
+        });
+        const expectedMr = MatchRating.create({
+            match: makeMatch30(strongHome, weakAway),
+            context: { kind: 'LEAGUE', tier: 1, homeIsBot: false, awayIsBot: false }
+        });
+        // Equal-match 3-0 win earns more points than a heavily favoured 3-0 win
+        expect(surpriseMr.getPoints(MatchTeam.HOME))
+            .toBeGreaterThan(expectedMr.getPoints(MatchTeam.HOME));
+    });
+    it('3-1 win earns fewer points than a 3-0 win (SSV difference)', () => {
+        const home = makeTeam({ rating: 1000 });
+        const away = makeTeam({ rating: 1000 });
+        const win30 = MatchRating.create({
+            match: makeMatch30(home, away),
+            context: { kind: 'LEAGUE', tier: 1, homeIsBot: false, awayIsBot: false }
+        });
+        const away2 = makeTeam({ rating: 1000 });
+        const win31 = MatchRating.create({
+            match: makeMatch31(home, away2),
+            context: { kind: 'LEAGUE', tier: 1, homeIsBot: false, awayIsBot: false }
+        });
+        expect(win30.getPoints(MatchTeam.HOME)).toBeGreaterThan(win31.getPoints(MatchTeam.HOME));
+    });
+});

package/dist/esm/src/service/match/match-set.d.ts

@@ -1,43 +1,33 @@
-import { PlayerPosition, Rally } from './rally';
-import { MatchTeam } from './match-team';
-import { BoxScore } from './box-score';
-type ScoreThreshold = 25 | 15;
-interface MatchSetParams {
-    readonly id: string;
-    readonly order: number;
-    readonly isTieBreak: boolean;
-    readonly homePlayerPosition: PlayerPosition[];
-    readonly awayPlayerPosition: PlayerPosition[];
-    readonly homeScore: number;
-    readonly awayScore: number;
-    readonly boxScores: BoxScore[];
-    readonly rallies: Rally[];
-}
-export declare class MatchSet {
-    readonly id: string;
-    readonly order: number;
-    readonly isTieBreak: boolean;
-    readonly homePlayerPosition: PlayerPosition[];
-    readonly awayPlayerPosition: PlayerPosition[];
-    readonly boxScores: BoxScore[];
-    readonly rallies: Rally[];
-    readonly scoreThreshold: ScoreThreshold;
-    private _homeScore;
-    private _awayScore;
-    constructor({ id, order, isTieBreak, homePlayerPosition, awayPlayerPosition, boxScores, rallies, homeScore, awayScore }: MatchSetParams);
-    get homeScore(): number;
-    get awayScore(): number;
-    increaseScore(team: MatchTeam): void;
-    addRally(rally: Rally): void;
-    /**
-     * Has a team reached at least 25 points, and is the score difference between both teams at least 2?
-     * @returns boolean
-     */
-    isOver(): boolean;
-    /**
-     * Get the team that won the Set. Return undefined if set is not over.
-     * @returns CourtTeam
-     */
-    getWinner(): MatchTeam;
-}
-export {};
+import { PlayerPosition, Rally } from './rally';
+import { MatchTeam } from './match-team';
+import { BoxScore } from './box-score';
+type ScoreThreshold = 25 | 15;
+export declare class MatchSet {
+    readonly id: string;
+    readonly order: number;
+    readonly isTieBreak: boolean;
+    readonly homePlayerPosition: PlayerPosition[];
+    readonly awayPlayerPosition: PlayerPosition[];
+    readonly boxScores: BoxScore[];
+    readonly rallies: Rally[];
+    readonly scoreThreshold: ScoreThreshold;
+    private _homeScore;
+    private _awayScore;
+    static create(input: unknown): MatchSet;
+    private constructor();
+    get homeScore(): number;
+    get awayScore(): number;
+    increaseScore(team: MatchTeam): void;
+    addRally(rally: Rally): void;
+    /**
+     * Has a team reached at least 25 points, and is the score difference between both teams at least 2?
+     * @returns boolean
+     */
+    isOver(): boolean;
+    /**
+     * Get the team that won the Set. Return undefined if set is not over.
+     * @returns CourtTeam
+     */
+    getWinner(): MatchTeam;
+}
+export {};

package/dist/esm/src/service/match/match-set.js

@@ -1,51 +1,62 @@
-import { validateUUID } from '../utils';
-import { MatchTeam } from './match-team';
-export class MatchSet {
-    constructor({ id, order, isTieBreak, homePlayerPosition, awayPlayerPosition, boxScores, rallies, homeScore, awayScore }) {
-        validateUUID(id);
-        this.id = id;
-        this.order = order;
-        this._homeScore = homeScore;
-        this._awayScore = awayScore;
-        this.homePlayerPosition = homePlayerPosition;
-        this.awayPlayerPosition = awayPlayerPosition;
-        this.boxScores = boxScores;
-        this.rallies = rallies;
-        this.isTieBreak = isTieBreak;
-        this.scoreThreshold = isTieBreak ? 15 : 25;
-    }
-    get homeScore() {
-        return this._homeScore;
-    }
-    get awayScore() {
-        return this._awayScore;
-    }
-    increaseScore(team) {
-        if (team === MatchTeam.HOME)
-            this._homeScore++;
-        else if (team === MatchTeam.AWAY)
-            this._awayScore++;
-        else
-            throw new Error('UNKNOWN_TEAM');
-    }
-    addRally(rally) {
-        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
-     */
-    isOver() {
-        return Math.abs(this.homeScore - this.awayScore) > 1 &&
-            (this.homeScore >= this.scoreThreshold || this.awayScore >= this.scoreThreshold);
-    }
-    /**
-     * Get the team that won the Set. Return undefined if set is not over.
-     * @returns CourtTeam
-     */
-    getWinner() {
-        if (!this.isOver())
-            throw new Error('UNFINISHED_SET');
-        return this.homeScore > this.awayScore ? MatchTeam.HOME : MatchTeam.AWAY;
-    }
-}
+import { MatchTeam } from './match-team';
+import { MatchSetInputSchema } from './schemas/match-set.z';
+export class MatchSet {
+    static create(input) {
+        const result = MatchSetInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_MATCH_SET: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new MatchSet(result.data);
+    }
+    constructor({ id, order, isTieBreak, homePlayerPosition, awayPlayerPosition, boxScores, rallies, homeScore, awayScore }) {
+        this.id = id;
+        this.order = order;
+        this._homeScore = homeScore;
+        this._awayScore = awayScore;
+        this.homePlayerPosition = homePlayerPosition;
+        this.awayPlayerPosition = awayPlayerPosition;
+        this.boxScores = boxScores;
+        this.rallies = rallies;
+        this.isTieBreak = isTieBreak;
+        this.scoreThreshold = isTieBreak ? 15 : 25;
+    }
+    get homeScore() {
+        return this._homeScore;
+    }
+    get awayScore() {
+        return this._awayScore;
+    }
+    increaseScore(team) {
+        if (team === MatchTeam.HOME)
+            this._homeScore++;
+        else if (team === MatchTeam.AWAY)
+            this._awayScore++;
+        else
+            throw new Error('UNKNOWN_TEAM');
+    }
+    addRally(rally) {
+        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
+     */
+    isOver() {
+        return Math.abs(this.homeScore - this.awayScore) > 1 &&
+            (this.homeScore >= this.scoreThreshold || this.awayScore >= this.scoreThreshold);
+    }
+    /**
+     * Get the team that won the Set. Return undefined if set is not over.
+     * @returns CourtTeam
+     */
+    getWinner() {
+        if (!this.isOver())
+            throw new Error('UNFINISHED_SET');
+        return this.homeScore > this.awayScore ? MatchTeam.HOME : MatchTeam.AWAY;
+    }
+}

package/dist/esm/src/service/match/match-set.test.d.ts

@@ -0,0 +1 @@
+export {};