@jjlmoya/utils-sports 1.19.0 → 1.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-sports",
-    "version": "1.19.0",
+    "version": "1.20.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",

package/src/entries.ts

@@ -12,6 +12,8 @@ export { scoreKeeper } from './tool/scoreKeeper/entry';
 export type { ScoreKeeperLocaleContent } from './tool/scoreKeeper/entry';
 export { tournamentBracket } from './tool/tournamentBracket/entry';
 export type { TournamentBracketLocaleContent } from './tool/tournamentBracket/entry';
+export { tennisScoreKeeper } from './tool/tennisScoreKeeper/entry';
+export type { TennisScoreKeeperLocaleContent } from './tool/tennisScoreKeeper/entry';
 export { sportsCategory } from './category';
 import { basketScoreKeeper } from './tool/basketScoreKeeper/entry';
 import { footballScoreKeeper } from './tool/footballScoreKeeper/entry';
@@ -20,4 +22,5 @@ import { pingPongScoreKeeper } from './tool/pingPongScoreKeeper/entry';
 import { reactionTester } from './tool/reactionTester/entry';
 import { scoreKeeper } from './tool/scoreKeeper/entry';
 import { tournamentBracket } from './tool/tournamentBracket/entry';
-export const ALL_ENTRIES = [basketScoreKeeper, footballScoreKeeper, gymTracker, pingPongScoreKeeper, reactionTester, scoreKeeper, tournamentBracket];
+import { tennisScoreKeeper } from './tool/tennisScoreKeeper/entry';
+export const ALL_ENTRIES = [basketScoreKeeper, footballScoreKeeper, gymTracker, pingPongScoreKeeper, reactionTester, scoreKeeper, tournamentBracket, tennisScoreKeeper];

package/src/tests/locale_completeness.test.ts

@@ -3,6 +3,6 @@ import { ALL_TOOLS } from '../tools';
 
 describe('Locale Completeness Validation', () => {
   it('all tools registered', () => {
-    expect(ALL_TOOLS.length).toBe(7);
+    expect(ALL_TOOLS.length).toBe(8);
   });
 });

package/src/tests/tool_validation.test.ts

@@ -4,8 +4,8 @@ import { sportsCategory } from '../data';
 
 describe('Tool Validation Suite', () => {
   describe('Library Registration', () => {
-    it('should have 7 tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(7);
+    it('should have 8 tools in ALL_TOOLS', () => {
+      expect(ALL_TOOLS.length).toBe(8);
     });
 
     it('sportsCategory should be defined', () => {

package/src/tool/tennisScoreKeeper/bibliography.astro

@@ -0,0 +1,6 @@
+---
+import { Bibliography as SharedBibliography } from '@jjlmoya/utils-shared';
+import { bibliography } from './bibliography';
+---
+
+<SharedBibliography links={bibliography} />

package/src/tool/tennisScoreKeeper/bibliography.ts

@@ -0,0 +1,8 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  {
+    name: 'ITF Rules of Tennis',
+    url: 'https://www.itftennis.com/en/about-us/governance/rules-and-regulations/',
+  },
+];

package/src/tool/tennisScoreKeeper/component.astro

@@ -0,0 +1,164 @@
+---
+import type { KnownLocale } from '../../types';
+import type { TennisScoreKeeperUI } from './ui';
+
+interface Props {
+  locale?: KnownLocale;
+  ui?: Record<string, unknown>;
+}
+
+const { ui } = Astro.props;
+const t = (ui ?? {}) as TennisScoreKeeperUI;
+---
+
+<div class="tn-console" id="tn-card" data-tn-ui={JSON.stringify(t)}>
+  <div class="tn-header-panel">
+    <div class="tn-header-actions">
+      <button class="tn-action-btn" data-tn-reset title={t.reset}>
+        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+          <path d="M3 12a9 9 0 0 1 9-9 9.75 9.75 0 0 1 6.74 2.74L21 8"/>
+          <path d="M16 3h5v5M21 12a9 9 0 0 1-9 9 9.75 9.75 0 0 1-6.74-2.74L3 16"/>
+          <path d="M8 21H3v-5"/>
+        </svg>
+      </button>
+      <button class="tn-action-btn" data-tn-fs title={t.fullscreen}>
+        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round">
+          <path d="M15 3h6v6M9 21H3v-6M21 3l-7 7M3 21l7-7"/>
+        </svg>
+      </button>
+    </div>
+  </div>
+
+  <div class="tn-3d-arena">
+    <div class="tn-court" id="tn-interactive-court">
+      <div class="tn-court-markings">
+        <svg viewBox="0 0 100 150" preserveAspectRatio="none">
+          <rect x="5" y="5" width="90" height="140" fill="none" stroke="white" stroke-width="1.5"/>
+          <line x1="5" y1="75" x2="95" y2="75" stroke="white" stroke-width="2.5"/>
+          <line x1="18" y1="5" x2="18" y2="145" stroke="white" stroke-width="1"/>
+          <line x1="82" y1="5" x2="82" y2="145" stroke="white" stroke-width="1"/>
+          <line x1="50" y1="30" x2="50" y2="120" stroke="white" stroke-width="1.2"/>
+          <line x1="18" y1="30" x2="82" y2="30" stroke="white" stroke-width="1.2"/>
+          <line x1="18" y1="120" x2="82" y2="120" stroke="white" stroke-width="1.2"/>
+          <line x1="50" y1="5" x2="50" y2="8" stroke="white" stroke-width="1.5"/>
+          <line x1="50" y1="142" x2="50" y2="145" stroke="white" stroke-width="1.5"/>
+        </svg>
+      </div>
+
+      <div class="tn-net">
+        <div class="tn-net-mesh"></div>
+        <div class="tn-net-strap"></div>
+      </div>
+
+      <div class="tn-ripple-field" id="tn-ripples"></div>
+
+      <div class="tn-court-half tn-court-half-a" id="tn-court-half-a">
+        <div class="tn-player-hud">
+          <div class="tn-player-name-section">
+            <svg class="tn-court-racquet" id="tn-racquet-a" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
+              <ellipse cx="12" cy="8" rx="5" ry="6" />
+              <path d="M9 8h6M10 5h4M10 11h4M12 2v12M10 3v10M14 3v10" stroke-width="0.8" opacity="0.6"/>
+              <path d="M9.5 13.5L12 16.5L14.5 13.5M11 16.5h2v6.5h-2z" />
+            </svg>
+            <input type="text" value={t.playerA} class="tn-player-input" id="tn-name-a" list="tn-names-a" />
+            <datalist id="tn-names-a"></datalist>
+          </div>
+          <div class="tn-hud-sets" id="tn-sets-a"></div>
+        </div>
+
+        <div class="tn-court-score-box">
+          <span class="tn-court-score" id="tn-score-val-a">0</span>
+          <span class="tn-court-games" id="tn-games-a">{t.game}: 0</span>
+        </div>
+      </div>
+
+      <div class="tn-court-half tn-court-half-b" id="tn-court-half-b">
+        <div class="tn-court-score-box">
+          <span class="tn-court-games" id="tn-games-b">{t.game}: 0</span>
+          <span class="tn-court-score" id="tn-score-val-b">0</span>
+        </div>
+
+        <div class="tn-player-hud">
+          <div class="tn-player-name-section">
+            <svg class="tn-court-racquet" id="tn-racquet-b" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
+              <ellipse cx="12" cy="8" rx="5" ry="6" />
+              <path d="M9 8h6M10 5h4M10 11h4M12 2v12M10 3v10M14 3v10" stroke-width="0.8" opacity="0.6"/>
+              <path d="M9.5 13.5L12 16.5L14.5 13.5M11 16.5h2v6.5h-2z" />
+            </svg>
+            <input type="text" value={t.playerB} class="tn-player-input" id="tn-name-b" list="tn-names-b" />
+            <datalist id="tn-names-b"></datalist>
+          </div>
+          <div class="tn-hud-sets" id="tn-sets-b"></div>
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <div class="tn-status-banner" id="tn-status"></div>
+
+  <div class="tn-console-controls">
+    <div class="tn-control-group">
+      <button class="tn-control-btn tn-btn-mode tn-mode-active" data-mode-bo3>{t.bo3}</button>
+      <button class="tn-control-btn tn-btn-mode" data-mode-bo5>{t.bo5}</button>
+    </div>
+
+    <div class="tn-control-group">
+      <button class="tn-control-btn tn-btn-minus" data-minus-a title="Undo Player A">&minus; A</button>
+      <button class="tn-control-btn tn-btn-minus" data-minus-b title="Undo Player B">&minus; B</button>
+    </div>
+  </div>
+
+  <div class="tn-history-grid" id="tn-history">
+    <div class="tn-history-row" id="tn-row-a">
+      <div class="tn-serving-indicator-col" id="tn-hist-serve-a"></div>
+      <div class="tn-history-name" id="tn-hist-name-a">{t.playerA}</div>
+      <div class="tn-history-sets" id="tn-set-list-a"></div>
+    </div>
+    <div class="tn-history-row" id="tn-row-b">
+      <div class="tn-serving-indicator-col" id="tn-hist-serve-b"></div>
+      <div class="tn-history-name" id="tn-hist-name-b">{t.playerB}</div>
+      <div class="tn-history-sets" id="tn-set-list-b"></div>
+    </div>
+  </div>
+
+  <div id="tn-swap" class="tn-swap-overlay">
+    <div class="tn-swap-toast" data-tn-swap-btn>
+      <svg class="tn-swap-toast-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+        <path d="M17 17H3m14 0l-4-4m4 4l-4 4M7 7h14M7 7l4-4M7 7l4 4"/>
+      </svg>
+      <div>
+        <div class="tn-toast-title">{t.changeSide}</div>
+        <div class="tn-toast-sub">{t.swapHint}</div>
+      </div>
+    </div>
+  </div>
+
+  <div id="tn-winner" class="tn-celebration-screen">
+    <div class="tn-celebration-box">
+      <svg class="tn-celebration-cup" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+        <path d="M6 9H4.5a2.5 2.5 0 0 1 0-5H6m12 5h1.5a2.5 2.5 0 0 0 0-5H18M6 4h12M12 18v3m-4 0h8m-4-17v14a4 4 0 0 1-4-4"/>
+      </svg>
+      <div class="tn-celebration-label">{t.winnerLabel}</div>
+      <div id="tn-winner-team" class="tn-celebration-name">Player 1</div>
+      <div id="tn-winner-score" class="tn-celebration-score">0 - 0</div>
+      <button class="tn-celebration-btn" data-close-winner>&times;</button>
+    </div>
+  </div>
+
+  <div id="tn-confetti" class="tn-confetti-field"></div>
+
+  <div id="tn-modal" class="tn-inline-modal">
+    <div class="tn-inline-modal-box">
+      <p class="tn-inline-modal-text">{t.resetConfirm}</p>
+      <div class="tn-inline-modal-btns">
+        <button id="tn-modal-cancel" class="tn-inline-modal-btn tn-inline-btn-cancel">{t.cancel}</button>
+        <button id="tn-modal-confirm" class="tn-inline-modal-btn tn-inline-btn-reset">{t.reset}</button>
+      </div>
+    </div>
+  </div>
+</div>
+
+<script>
+  import { initTennisScoreKeeper } from './logic';
+  initTennisScoreKeeper();
+</script>

package/src/tool/tennisScoreKeeper/entry.ts

@@ -0,0 +1,30 @@
+import type { SportsToolEntry, ToolLocaleContent } from '../../types';
+import type { TennisScoreKeeperUI } from './ui';
+
+export type { TennisScoreKeeperUI };
+export type TennisScoreKeeperLocaleContent = ToolLocaleContent<TennisScoreKeeperUI>;
+
+export const tennisScoreKeeper: SportsToolEntry<TennisScoreKeeperUI> = {
+  id: 'tennis-scorekeeper',
+  icons: {
+    bg: 'mdi:tennis',
+    fg: 'mdi:scoreboard-outline',
+  },
+  i18n: {
+    en: () => import('./i18n/en').then((m) => m.content),
+    es: () => import('./i18n/es').then((m) => m.content),
+    fr: () => import('./i18n/fr').then((m) => m.content),
+    de: () => import('./i18n/de').then((m) => m.content),
+    id: () => import('./i18n/id').then((m) => m.content),
+    it: () => import('./i18n/it').then((m) => m.content),
+    ja: () => import('./i18n/ja').then((m) => m.content),
+    ko: () => import('./i18n/ko').then((m) => m.content),
+    nl: () => import('./i18n/nl').then((m) => m.content),
+    pl: () => import('./i18n/pl').then((m) => m.content),
+    pt: () => import('./i18n/pt').then((m) => m.content),
+    ru: () => import('./i18n/ru').then((m) => m.content),
+    sv: () => import('./i18n/sv').then((m) => m.content),
+    tr: () => import('./i18n/tr').then((m) => m.content),
+    zh: () => import('./i18n/zh').then((m) => m.content),
+  },
+};

package/src/tool/tennisScoreKeeper/events.ts

@@ -0,0 +1,136 @@
+import type { TennisScoreKeeperUI } from './ui';
+import { type PlayerSide, type MatchFormat } from './game-logic';
+import { el } from './render';
+
+export interface TennisAPI {
+  addPoint: (player: PlayerSide, e?: MouseEvent) => void;
+  minusPoint: (player: PlayerSide) => void;
+  setMode: (mode: MatchFormat) => void;
+  reset: () => void;
+  resetAll: () => void;
+  confirmReset: () => void;
+  cancelReset: () => void;
+  toggleFullscreen: () => void;
+  confirmSwap: () => void;
+}
+
+const NAMES_KEY = 'tn_names';
+const HISTORY_KEY = 'tn_history';
+
+export function saveNames(a: string, b: string): void {
+  localStorage.setItem(NAMES_KEY, JSON.stringify({ a, b }));
+}
+
+export function loadNames(): { a: string; b: string } {
+  try {
+    return JSON.parse(localStorage.getItem(NAMES_KEY) || '{"a":"Player 1","b":"Player 2"}');
+  } catch {
+    return { a: 'Player 1', b: 'Player 2' };
+  }
+}
+
+export function getAllKnownNames(): string[] {
+  const h: Record<string, { w: number; l: number }> = JSON.parse(localStorage.getItem(HISTORY_KEY) || '{}');
+  return Object.keys(h).sort();
+}
+
+export function recordMatchOutcome(winner: string, loser: string): void {
+  const w = winner.trim();
+  const l = loser.trim();
+  const h: Record<string, { w: number; l: number }> = JSON.parse(localStorage.getItem(HISTORY_KEY) || '{}');
+  if (w) { h[w] = h[w] || { w: 0, l: 0 }; h[w].w += 1; }
+  if (l) { h[l] = h[l] || { w: 0, l: 0 }; h[l].l += 1; }
+  localStorage.setItem(HISTORY_KEY, JSON.stringify(h));
+
+  const names = getAllKnownNames();
+  ['tn-names-a', 'tn-names-b'].forEach((id) => {
+    const dl = document.getElementById(id) as HTMLDataListElement;
+    if (dl) dl.innerHTML = names.map((n) => `<option value="${n}">`).join('');
+  });
+}
+
+function isModeButton(target: HTMLElement, api: TennisAPI): boolean {
+  if (target.closest('[data-mode-bo3]')) { api.setMode('bo3'); return true; }
+  if (target.closest('[data-mode-bo5]')) { api.setMode('bo5'); return true; }
+  return false;
+}
+
+function isCourtClick(target: HTMLElement, e: MouseEvent, api: TennisAPI): boolean {
+  const halfA = target.closest('#tn-court-half-a');
+  if (halfA && !target.closest('.tn-player-input') && !target.closest('.tn-hud-sets')) { api.addPoint('a', e); return true; }
+  const halfB = target.closest('#tn-court-half-b');
+  if (halfB && !target.closest('.tn-player-input') && !target.closest('.tn-hud-sets')) { api.addPoint('b', e); return true; }
+  return false;
+}
+
+function isMinusButton(target: HTMLElement, api: TennisAPI): boolean {
+  if (target.closest('[data-minus-a]')) { api.minusPoint('a'); return true; }
+  if (target.closest('[data-minus-b]')) { api.minusPoint('b'); return true; }
+  return false;
+}
+
+function isSpecialButton(target: HTMLElement, api: TennisAPI): boolean {
+  if (target.closest('[data-close-winner]')) { el('tn-winner')?.classList.remove('tn-winner-active'); api.resetAll(); return true; }
+  if (target.closest('[data-tn-swap-btn]')) { api.confirmSwap(); return true; }
+  if (target.closest('#tn-modal-cancel')) { api.cancelReset(); return true; }
+  if (target.closest('#tn-modal-confirm')) { api.confirmReset(); return true; }
+  if (target.closest('[data-tn-reset]')) { api.reset(); return true; }
+  return false;
+}
+
+export function setupClickEvents(api: TennisAPI): void {
+  document.addEventListener('click', (e) => {
+    const target = e.target as HTMLElement;
+    if (isSpecialButton(target, api)) return;
+    if (isModeButton(target, api)) return;
+    if (isCourtClick(target, e, api)) return;
+    isMinusButton(target, api);
+  });
+}
+
+export function setupFullscreen(card: HTMLElement, api: TennisAPI): void {
+  const fsBtn = card.querySelector('[data-tn-fs]');
+  fsBtn?.addEventListener('click', (e) => {
+    e.stopPropagation();
+    api.toggleFullscreen();
+  });
+
+  document.addEventListener('fullscreenchange', () => {
+    const isFs = !!document.fullscreenElement;
+    card.classList.toggle('tn-fullscreen-on', isFs);
+    if (!isFs) card.classList.remove('tn-fullscreen-fallback');
+  });
+}
+
+export function setupNameInputs(score: Record<string, unknown>, save: () => void): void {
+  const na = document.getElementById('tn-name-a') as HTMLInputElement;
+  const nb = document.getElementById('tn-name-b') as HTMLInputElement;
+  [na, nb].forEach((inp) => {
+    if (!inp) return;
+    inp.addEventListener('input', () => {
+      const a = (document.getElementById('tn-name-a') as HTMLInputElement)?.value || 'Player 1';
+      const b = (document.getElementById('tn-name-b') as HTMLInputElement)?.value || 'Player 2';
+      saveNames(a, b);
+      save();
+    });
+  });
+}
+
+export function populateDatalists(): void {
+  const names = getAllKnownNames();
+  ['tn-names-a', 'tn-names-b'].forEach((id) => {
+    const dl = document.getElementById(id) as HTMLDataListElement;
+    if (!dl) return;
+    dl.innerHTML = names.map((n) => `<option value="${n}">`).join('');
+  });
+}
+
+export function setupUI(t: TennisScoreKeeperUI): void {
+  const saved = loadNames();
+  t.playerA = saved.a;
+  t.playerB = saved.b;
+  const na = document.getElementById('tn-name-a') as HTMLInputElement;
+  const nb = document.getElementById('tn-name-b') as HTMLInputElement;
+  if (na) na.value = saved.a;
+  if (nb) nb.value = saved.b;
+}

package/src/tool/tennisScoreKeeper/game-logic.ts

@@ -0,0 +1,248 @@
+export type PlayerSide = 'a' | 'b';
+export type MatchFormat = 'bo3' | 'bo5';
+
+export interface SetScore {
+  gamesA: number;
+  gamesB: number;
+  tiebreakPointsA?: number;
+  tiebreakPointsB?: number;
+}
+
+export interface MatchScore {
+  currentGamePointsA: number;
+  currentGamePointsB: number;
+  setHistory: SetScore[];
+  gamesWonInCurrentSetA: number;
+  gamesWonInCurrentSetB: number;
+  setsWonA: number;
+  setsWonB: number;
+  servingPlayer: PlayerSide;
+  format: MatchFormat;
+  areSidesSwapped: boolean;
+  inTiebreak: boolean;
+  tiebreakPointsA: number;
+  tiebreakPointsB: number;
+  firstServerOfSet: PlayerSide;
+}
+
+export function createInitialScore(): MatchScore {
+  return {
+    currentGamePointsA: 0,
+    currentGamePointsB: 0,
+    setHistory: [],
+    gamesWonInCurrentSetA: 0,
+    gamesWonInCurrentSetB: 0,
+    setsWonA: 0,
+    setsWonB: 0,
+    servingPlayer: 'a',
+    format: 'bo3',
+    areSidesSwapped: false,
+    inTiebreak: false,
+    tiebreakPointsA: 0,
+    tiebreakPointsB: 0,
+    firstServerOfSet: 'a',
+  };
+}
+
+export function setsNeededForMatchWin(format: MatchFormat): number {
+  return format === 'bo3' ? 2 : 3;
+}
+
+function standardPointLabel(points: number, opponentPoints: number): string {
+  if (points <= 1) return points === 0 ? '0' : '15';
+  if (points === 2) return '30';
+  if (points === 3 || points === opponentPoints) return '40';
+  if (points - opponentPoints === 1) return 'Ad';
+  return '0';
+}
+
+export function getPointLabel(points: number, opponentPoints: number, inTiebreak: boolean): string {
+  return inTiebreak ? String(points) : standardPointLabel(points, opponentPoints);
+}
+
+export function checkMatchOver(score: MatchScore): PlayerSide | null {
+  const need = setsNeededForMatchWin(score.format);
+  if (score.setsWonA >= need) return 'a';
+  if (score.setsWonB >= need) return 'b';
+  return null;
+}
+
+function tiebreakSetWinner(score: MatchScore): PlayerSide | null {
+  if (score.tiebreakPointsA >= 7 && score.tiebreakPointsA - score.tiebreakPointsB >= 2) return 'a';
+  if (score.tiebreakPointsB >= 7 && score.tiebreakPointsB - score.tiebreakPointsA >= 2) return 'b';
+  return null;
+}
+
+function regularSetWinner(a: number, b: number): PlayerSide | null {
+  if (a >= 6 && a - b >= 2) return 'a';
+  if (b >= 6 && b - a >= 2) return 'b';
+  return null;
+}
+
+export function checkSetOver(score: MatchScore): PlayerSide | null {
+  if (score.inTiebreak) return tiebreakSetWinner(score);
+  return regularSetWinner(score.gamesWonInCurrentSetA, score.gamesWonInCurrentSetB);
+}
+
+export function checkGameOver(score: MatchScore): PlayerSide | null {
+  if (score.inTiebreak) {
+    return null;
+  }
+  const a = score.currentGamePointsA;
+  const b = score.currentGamePointsB;
+  if (a >= 4 && a - b >= 2) return 'a';
+  if (b >= 4 && b - a >= 2) return 'b';
+  return null;
+}
+
+function tiebreakPointWinner(a: number, b: number): PlayerSide | null {
+  if (a >= 6 && a > b) return 'a';
+  if (b >= 6 && b > a) return 'b';
+  return null;
+}
+
+function gamePointWinner(a: number, b: number): PlayerSide | null {
+  if (a >= 3 && a > b) return 'a';
+  if (b >= 3 && b > a) return 'b';
+  return null;
+}
+
+export function checkPointWinnerOpportunity(score: MatchScore): PlayerSide | null {
+  if (checkMatchOver(score)) return null;
+  return score.inTiebreak
+    ? tiebreakPointWinner(score.tiebreakPointsA, score.tiebreakPointsB)
+    : gamePointWinner(score.currentGamePointsA, score.currentGamePointsB);
+}
+
+function isSetPointForSide(gamesLeader: number, gamesTrailer: number): boolean {
+  return (gamesLeader === 5 && gamesTrailer <= 4) || (gamesLeader === 6 && gamesTrailer === 5);
+}
+
+export function isSetPoint(score: MatchScore): PlayerSide | null {
+  const opp = checkPointWinnerOpportunity(score);
+  if (!opp) return null;
+  if (score.inTiebreak) return opp;
+  const gA = score.gamesWonInCurrentSetA;
+  const gB = score.gamesWonInCurrentSetB;
+  if (opp === 'a' && isSetPointForSide(gA, gB)) return 'a';
+  if (opp === 'b' && isSetPointForSide(gB, gA)) return 'b';
+  return null;
+}
+
+export function isMatchPoint(score: MatchScore): PlayerSide | null {
+  const sp = isSetPoint(score);
+  if (!sp) return null;
+  const need = setsNeededForMatchWin(score.format);
+  if (sp === 'a' && score.setsWonA === need - 1) return 'a';
+  if (sp === 'b' && score.setsWonB === need - 1) return 'b';
+  return null;
+}
+
+function getTiebreakServer(firstServer: PlayerSide, totalPoints: number): PlayerSide {
+  if (totalPoints % 2 === 1) return oppositeSide(firstServer);
+  return ((totalPoints / 2) % 2 === 1) ? oppositeSide(firstServer) : firstServer;
+}
+
+function oppositeSide(side: PlayerSide): PlayerSide {
+  return side === 'a' ? 'b' : 'a';
+}
+
+function awardTiebreakPoint(next: MatchScore, side: PlayerSide): void {
+  if (side === 'a') next.tiebreakPointsA += 1;
+  else next.tiebreakPointsB += 1;
+  next.servingPlayer = getTiebreakServer(next.firstServerOfSet, next.tiebreakPointsA + next.tiebreakPointsB);
+}
+
+function awardRegularPoint(next: MatchScore, side: PlayerSide): void {
+  if (side === 'a') next.currentGamePointsA += 1;
+  else next.currentGamePointsB += 1;
+}
+
+export function awardPointToPlayer(score: MatchScore, side: PlayerSide): MatchScore {
+  if (checkMatchOver(score)) return score;
+  const next = { ...score };
+  if (next.inTiebreak) awardTiebreakPoint(next, side);
+  else awardRegularPoint(next, side);
+  return next;
+}
+
+function undoLastTiebreakPoint(next: MatchScore, side: PlayerSide): boolean {
+  if (side === 'a' && next.tiebreakPointsA > 0) next.tiebreakPointsA -= 1;
+  else if (side === 'b' && next.tiebreakPointsB > 0) next.tiebreakPointsB -= 1;
+  else return false;
+  next.servingPlayer = getTiebreakServer(next.firstServerOfSet, next.tiebreakPointsA + next.tiebreakPointsB);
+  return true;
+}
+
+function undoLastRegularPoint(next: MatchScore, side: PlayerSide): boolean {
+  if (side === 'a' && next.currentGamePointsA > 0) next.currentGamePointsA -= 1;
+  else if (side === 'b' && next.currentGamePointsB > 0) next.currentGamePointsB -= 1;
+  else return false;
+  return true;
+}
+
+export function undoLastPoint(score: MatchScore, side: PlayerSide): MatchScore {
+  if (checkMatchOver(score)) return score;
+  const next = { ...score };
+  const ok = next.inTiebreak
+    ? undoLastTiebreakPoint(next, side)
+    : undoLastRegularPoint(next, side);
+  return ok ? next : score;
+}
+
+export function concludeGame(score: MatchScore, gameWinner: PlayerSide): MatchScore {
+  const next = { ...score };
+  if (gameWinner === 'a') {
+    next.gamesWonInCurrentSetA += 1;
+  } else {
+    next.gamesWonInCurrentSetB += 1;
+  }
+  next.currentGamePointsA = 0;
+  next.currentGamePointsB = 0;
+  next.servingPlayer = next.servingPlayer === 'a' ? 'b' : 'a';
+  if (next.gamesWonInCurrentSetA === 6 && next.gamesWonInCurrentSetB === 6) {
+    next.inTiebreak = true;
+    next.tiebreakPointsA = 0;
+    next.tiebreakPointsB = 0;
+  }
+  return next;
+}
+
+function makeSetHistoryItem(next: MatchScore, setWinner: PlayerSide): SetScore {
+  const item: SetScore = {
+    gamesA: next.gamesWonInCurrentSetA,
+    gamesB: next.gamesWonInCurrentSetB,
+  };
+  if (next.inTiebreak) {
+    item.tiebreakPointsA = next.tiebreakPointsA;
+    item.tiebreakPointsB = next.tiebreakPointsB;
+    item.gamesA = setWinner === 'a' ? 7 : 6;
+    item.gamesB = setWinner === 'a' ? 6 : 7;
+  }
+  return item;
+}
+
+function resetSetState(next: MatchScore): void {
+  next.gamesWonInCurrentSetA = 0;
+  next.gamesWonInCurrentSetB = 0;
+  next.currentGamePointsA = 0;
+  next.currentGamePointsB = 0;
+  next.inTiebreak = false;
+  next.tiebreakPointsA = 0;
+  next.tiebreakPointsB = 0;
+  next.firstServerOfSet = next.firstServerOfSet === 'a' ? 'b' : 'a';
+  next.servingPlayer = next.firstServerOfSet;
+}
+
+export function concludeSet(score: MatchScore, setWinner: PlayerSide): MatchScore {
+  const next = { ...score };
+  next.setHistory = [...next.setHistory, makeSetHistoryItem(next, setWinner)];
+  if (setWinner === 'a') next.setsWonA += 1;
+  else next.setsWonB += 1;
+  resetSetState(next);
+  return next;
+}
+
+export function createCleanMatch(score: MatchScore): MatchScore {
+  return { ...createInitialScore(), format: score.format };
+}