tods-competition-factory 2.2.35 → 2.2.37

package/dist/tods-competition-factory.development.cjs.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.2.35';
+    return '2.2.37';
 }
 
 const SINGLES_MATCHUP = 'SINGLES';
@@ -32159,10 +32159,11 @@ function validateSetScore(set, matchUpFormat, isDecidingSet, allowIncomplete) {
     const { setTo, tiebreakAt, tiebreakFormat, tiebreakSet } = setFormat;
     const tiebreakSetTo = tiebreakSet?.tiebreakTo;
     const isTiebreakOnlyFormat = !!tiebreakSetTo && !setTo;
-    const side1Score = set.side1Score || 0;
-    const side2Score = set.side2Score || 0;
     const side1TiebreakScore = set.side1TiebreakScore;
     const side2TiebreakScore = set.side2TiebreakScore;
+    const hasTiebreakScores = side1TiebreakScore !== undefined && side2TiebreakScore !== undefined;
+    const side1Score = isTiebreakOnlyFormat && hasTiebreakScores ? side1TiebreakScore : set.side1Score || set.side1 || 0;
+    const side2Score = isTiebreakOnlyFormat && hasTiebreakScores ? side2TiebreakScore : set.side2Score || set.side2 || 0;
     const winnerScore = Math.max(side1Score, side2Score);
     const loserScore = Math.min(side1Score, side2Score);
     const scoreDiff = winnerScore - loserScore;
@@ -32179,36 +32180,43 @@ function validateSetScore(set, matchUpFormat, isDecidingSet, allowIncomplete) {
                 error: `Tiebreak-only set winner must reach at least ${tiebreakSetTo}, got ${winnerScore}`,
             };
         }
-        if (loserScore < tiebreakSetTo - 1) {
+        if (scoreDiff < 2) {
+            return {
+                isValid: false,
+                error: `Tiebreak-only set must be won by at least 2 points, got ${winnerScore}-${loserScore}`,
+            };
+        }
+        if (winnerScore === tiebreakSetTo && loserScore > tiebreakSetTo - 2) {
             return {
                 isValid: false,
-                error: `Tiebreak-only set loser must be at least ${tiebreakSetTo - 1} when winner exceeds ${tiebreakSetTo}, got ${loserScore}`,
+                error: `Tiebreak-only set at ${tiebreakSetTo}-${loserScore} requires playing past ${tiebreakSetTo}`,
             };
         }
-        if (scoreDiff !== 2) {
+        if (winnerScore > tiebreakSetTo && scoreDiff !== 2) {
             return {
                 isValid: false,
-                error: `Tiebreak-only set must be won by exactly 2 points, got ${winnerScore}-${loserScore}`,
+                error: `Tiebreak-only set past ${tiebreakSetTo} must be won by exactly 2 points, got ${winnerScore}-${loserScore}`,
             };
         }
         return { isValid: true };
     }
     const hasExplicitTiebreak = side1TiebreakScore !== undefined || side2TiebreakScore !== undefined;
     const isImplicitTiebreak = setTo && winnerScore === setTo + 1 && loserScore === setTo;
-    const isLikelyTiebreak = tiebreakAt && winnerScore === tiebreakAt - 1 && loserScore === tiebreakAt - 2;
-    const hasTiebreak = hasExplicitTiebreak || isImplicitTiebreak || isLikelyTiebreak;
+    const hasTiebreak = hasExplicitTiebreak || isImplicitTiebreak;
     if (hasTiebreak) {
-        if (setTo && !isLikelyTiebreak) {
-            if (winnerScore !== setTo + 1) {
+        if (setTo && tiebreakAt) {
+            const expectedWinnerScore = tiebreakAt === setTo ? setTo + 1 : setTo;
+            const expectedLoserScore = tiebreakAt;
+            if (winnerScore !== expectedWinnerScore) {
                 return {
                     isValid: false,
-                    error: `Tiebreak set winner must have ${setTo + 1} games, got ${winnerScore}`,
+                    error: `Tiebreak set winner must have ${expectedWinnerScore} games, got ${winnerScore}`,
                 };
             }
-            if (loserScore !== setTo) {
+            if (loserScore !== expectedLoserScore) {
                 return {
                     isValid: false,
-                    error: `Tiebreak set loser must have ${setTo} games when tied, got ${loserScore}`,
+                    error: `Tiebreak set loser must have ${expectedLoserScore} games, got ${loserScore}`,
                 };
             }
         }
@@ -32267,33 +32275,33 @@ function validateSetScore(set, matchUpFormat, isDecidingSet, allowIncomplete) {
                 error: `Set winner must reach ${setTo} games, got ${winnerScore}`,
             };
         }
-        if (scoreDiff < 2) {
+        const isTiebreakWon = tiebreakAt && winnerScore === setTo && loserScore === tiebreakAt && scoreDiff === 1;
+        if (scoreDiff < 2 && !isTiebreakWon) {
             return {
                 isValid: false,
                 error: `Set must be won by at least 2 games, got ${winnerScore}-${loserScore}`,
             };
         }
         if (tiebreakAt) {
-            if (loserScore >= tiebreakAt) {
+            if (loserScore >= tiebreakAt && !isTiebreakWon) {
                 return {
                     isValid: false,
                     error: `When tied at ${tiebreakAt}-${tiebreakAt}, must play tiebreak. Use format like ${tiebreakAt + 1}-${tiebreakAt}(5)`,
                 };
             }
-            if (winnerScore > setTo + 1) {
+            const maxWinnerScore = tiebreakAt === setTo ? setTo + 1 : setTo;
+            if (winnerScore > maxWinnerScore) {
                 return {
                     isValid: false,
-                    error: `With tiebreak format, set score cannot exceed ${setTo + 1}-${setTo - 1}. Got ${winnerScore}-${loserScore}`,
+                    error: `With tiebreak format, set score cannot exceed ${maxWinnerScore}-${tiebreakAt}. Got ${winnerScore}-${loserScore}`,
                 };
             }
         }
-        else {
-            if (winnerScore > setTo + 10) {
-                return {
-                    isValid: false,
-                    error: `Set score ${winnerScore}-${loserScore} exceeds reasonable limits`,
-                };
-            }
+        else if (winnerScore > setTo + 10) {
+            return {
+                isValid: false,
+                error: `Set score ${winnerScore}-${loserScore} exceeds reasonable limits`,
+            };
         }
     }
     return { isValid: true };
@@ -32304,12 +32312,14 @@ function validateMatchUpScore(sets, matchUpFormat, matchUpStatus) {
     }
     const bestOfMatch = matchUpFormat?.match(/SET(\d+)/)?.[1];
     const bestOfSets = bestOfMatch ? Number.parseInt(bestOfMatch) : 3;
-    const hasIncompleteSet = sets.some((set) => !set.winningSide);
     const isIrregularEnding = [RETIRED$1, WALKOVER$2, DEFAULTED].includes(matchUpStatus || '');
-    const allowIncomplete = isIrregularEnding || (!matchUpStatus && hasIncompleteSet);
     for (let i = 0; i < sets.length; i++) {
-        const isDecidingSet = bestOfSets === 1 || i + 1 === bestOfSets;
-        const setValidation = validateSetScore(sets[i], matchUpFormat, isDecidingSet, allowIncomplete);
+        const set = sets[i];
+        const isDecidingSet = i + 1 === bestOfSets;
+        const setHasWinner = set.winningSide !== undefined;
+        const matchInProgress = matchUpStatus === undefined;
+        const allowIncomplete = isIrregularEnding || (matchInProgress && !setHasWinner);
+        const setValidation = validateSetScore(set, matchUpFormat, isDecidingSet, allowIncomplete);
         if (!setValidation.isValid) {
             return {
                 isValid: false,
@@ -32498,15 +32508,15 @@ function getHighTiebreakValue(params) {
 }
 
 function parseScoreString({ tiebreakTo = 7, scoreString = '', matchUpFormat }) {
-    let isTiebreakOnlyFormat = false;
+    let parsedFormat;
+    let bestOfSets = 3;
     if (matchUpFormat) {
         try {
-            const parsed = parse(matchUpFormat);
-            const tiebreakSetTo = parsed?.setFormat?.tiebreakSet?.tiebreakTo;
-            const regularSetTo = parsed?.setFormat?.setTo;
-            isTiebreakOnlyFormat = !!tiebreakSetTo && !regularSetTo;
+            parsedFormat = parse(matchUpFormat);
+            const bestOfMatch = matchUpFormat?.match(/SET(\d+)/)?.[1];
+            bestOfSets = bestOfMatch ? Number.parseInt(bestOfMatch) : 3;
         }
-        catch (e) {
+        catch (_e) {
         }
     }
     return scoreString
@@ -32519,6 +32529,16 @@ function parseScoreString({ tiebreakTo = 7, scoreString = '', matchUpFormat }) {
         const tiebreak = inParentheses.exec(set);
         const bracketed = inBrackets.exec(set);
         const isTiebreakOnlySet = set?.startsWith('[') && bracketed;
+        let isTiebreakOnlyFormat = false;
+        if (parsedFormat && isTiebreakOnlySet) {
+            const isDecidingSet = setNumber === bestOfSets;
+            const setFormat = isDecidingSet && parsedFormat.finalSetFormat ? parsedFormat.finalSetFormat : parsedFormat.setFormat;
+            if (setFormat) {
+                const tiebreakSetTo = setFormat.tiebreakSet?.tiebreakTo;
+                const regularSetTo = setFormat.setTo;
+                isTiebreakOnlyFormat = !!tiebreakSetTo && !regularSetTo;
+            }
+        }
         let side1Score;
         let side2Score;
         let side1TiebreakScore;
@@ -32534,12 +32554,13 @@ function parseScoreString({ tiebreakTo = 7, scoreString = '', matchUpFormat }) {
             else {
                 side1TiebreakScore = bracketedScores[0];
                 side2TiebreakScore = bracketedScores[1];
-                winningSide = (side1TiebreakScore > side2TiebreakScore && 1) || (side1TiebreakScore < side2TiebreakScore && 2) || undefined;
+                winningSide =
+                    (side1TiebreakScore > side2TiebreakScore && 1) || (side1TiebreakScore < side2TiebreakScore && 2) || undefined;
             }
         }
         else {
             const setString = (tiebreak && set.replace(tiebreak[0], '')) || (bracketed && set.replace(bracketed[0], '')) || set;
-            const setScores = setString.split('-').map((score) => parseInt(score));
+            const setScores = setString.split('-').map((score) => Number.parseInt(score));
             side1Score = setScores[0];
             side2Score = setScores[1];
             winningSide = (side1Score > side2Score && 1) || (side1Score < side2Score && 2) || undefined;
@@ -32555,7 +32576,7 @@ function parseScoreString({ tiebreakTo = 7, scoreString = '', matchUpFormat }) {
                 }
             }
             if (bracketed && !isTiebreakOnlySet) {
-                const matchTiebreakScores = bracketed[1].split('-').map((score) => parseInt(score));
+                const matchTiebreakScores = bracketed[1].split('-').map((score) => Number.parseInt(score));
                 side1TiebreakScore = matchTiebreakScores[0];
                 side2TiebreakScore = matchTiebreakScores[1];
             }