tods-competition-factory 2.2.40 → 2.2.42

package/dist/tods-competition-factory.d.ts

@@ -4626,11 +4626,11 @@ declare function deleteFlightProfileAndFlightDraws({ autoPublish, tournamentReco
     event: any;
     force: any;
 }): {
-    error: any;
-} | {
     success?: boolean;
     error?: ErrorType;
     info?: any;
+} | {
+    error: any;
 };
 
 type ModifyEventMatchUpFormatTimingArgs = {
@@ -4644,13 +4644,13 @@ type ModifyEventMatchUpFormatTimingArgs = {
     event?: Event$1;
 };
 declare function modifyEventMatchUpFormatTiming(params: ModifyEventMatchUpFormatTimingArgs): {
-    success: boolean;
-    error?: undefined;
-} | {
     error: {
         message: string;
         code: string;
     };
+} | {
+    success: boolean;
+    error?: undefined;
 };
 
 type RemoveEventMatchUpFormatTimingArgs = {

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.2.40';
+    return '2.2.42';
 }
 
 const SINGLES_MATCHUP = 'SINGLES';
@@ -1982,13 +1982,15 @@ const setTypes$1 = {
 };
 
 function stringify(matchUpFormatObject, preserveRedundant) {
+    if (!isObject(matchUpFormatObject))
+        return undefined;
     if ((matchUpFormatObject?.bestOf || matchUpFormatObject?.exactly) && matchUpFormatObject?.setFormat) {
         return getSetFormat(matchUpFormatObject, preserveRedundant);
     }
     return undefined;
 }
 function getNumber$1(formatstring) {
-    return !isNaN(Number(formatstring)) && Number(formatstring);
+    return !Number.isNaN(Number(formatstring)) && Number(formatstring);
 }
 function timedSetFormat(matchUpFormatObject) {
     let value = `T${matchUpFormatObject.minutes}`;
@@ -2025,7 +2027,7 @@ function getSetFormat(matchUpFormatObject, preserveRedundant) {
         '';
     const valid = setLimitCode && setCountValue;
     if (valid) {
-        return [setLimitCode, setCode, finalSetCode].filter((f) => f).join('-');
+        return [setLimitCode, setCode, finalSetCode].filter(Boolean).join('-');
     }
     return undefined;
 }
@@ -32184,7 +32186,7 @@ var help = {
     tidyScore: tidyScore
 };
 
-function validateTiebreakOnlySet(winnerScore, loserScore, scoreDiff, tiebreakSetTo, allowIncomplete) {
+function validateTiebreakOnlySet(winnerScore, loserScore, scoreDiff, tiebreakSetTo, allowIncomplete, NoAD = false) {
     if (allowIncomplete) {
         return { isValid: true };
     }
@@ -32197,12 +32199,18 @@ function validateTiebreakOnlySet(winnerScore, loserScore, scoreDiff, tiebreakSet
             error: `Tiebreak-only set winner must reach at least ${tiebreakSetTo}, got ${winnerScore}`,
         };
     }
-    if (scoreDiff < 2) {
+    const requiredWinBy = NoAD ? 1 : 2;
+    if (scoreDiff < requiredWinBy) {
         return {
             isValid: false,
-            error: `Tiebreak-only set must be won by at least 2 points, got ${winnerScore}-${loserScore}`,
+            error: NoAD
+                ? `Tiebreak-only set (NoAD) must be won by at least 1 point, got ${winnerScore}-${loserScore}`
+                : `Tiebreak-only set must be won by at least 2 points, got ${winnerScore}-${loserScore}`,
         };
     }
+    if (NoAD) {
+        return { isValid: true };
+    }
     if (winnerScore === tiebreakSetTo && loserScore > tiebreakSetTo - 2) {
         return {
             isValid: false,
@@ -32366,6 +32374,24 @@ function validateSetScore(set, matchUpFormat, isDecidingSet, allowIncomplete) {
     const setFormat = isDecidingSet && parsed.finalSetFormat ? parsed.finalSetFormat : parsed.setFormat;
     if (!setFormat)
         return { isValid: true };
+    if (setFormat.timed) {
+        if (!allowIncomplete) {
+            const side1Score = set.side1Score ?? 0;
+            const side2Score = set.side2Score ?? 0;
+            if (side1Score === 0 && side2Score === 0) {
+                return { isValid: false, error: 'Timed set requires at least one side to have scored' };
+            }
+            if (setFormat.based === 'P') {
+                if (side1Score === side2Score && side1Score > 0 && setFormat.tiebreakFormat) {
+                    const hasTiebreak = set.side1TiebreakScore !== undefined || set.side2TiebreakScore !== undefined;
+                    if (!hasTiebreak) {
+                        return { isValid: false, error: 'Tied timed set requires tiebreak' };
+                    }
+                }
+            }
+        }
+        return { isValid: true };
+    }
     const { setTo, tiebreakAt, tiebreakFormat, tiebreakSet } = setFormat;
     const tiebreakSetTo = tiebreakSet?.tiebreakTo;
     const isTiebreakOnlyFormat = !!tiebreakSetTo && !setTo;
@@ -32375,7 +32401,8 @@ function validateSetScore(set, matchUpFormat, isDecidingSet, allowIncomplete) {
     const loserScore = Math.min(side1Score, side2Score);
     const scoreDiff = winnerScore - loserScore;
     if (isTiebreakOnlyFormat) {
-        return validateTiebreakOnlySet(winnerScore, loserScore, scoreDiff, tiebreakSetTo, allowIncomplete ?? false);
+        const NoAD = setFormat.tiebreakSet?.NoAD ?? false;
+        return validateTiebreakOnlySet(winnerScore, loserScore, scoreDiff, tiebreakSetTo, allowIncomplete ?? false, NoAD);
     }
     const hasExplicitTiebreak = side1TiebreakScore !== undefined || side2TiebreakScore !== undefined;
     const isImplicitTiebreak = setTo && winnerScore === setTo + 1 && loserScore === setTo;
@@ -32613,94 +32640,115 @@ function getHighTiebreakValue(params) {
     return tiebreakTo;
 }
 
+function determineWinningSide(score1, score2) {
+    return (score1 > score2 && 1) || (score1 < score2 && 2) || undefined;
+}
+function parseTiebreakOnlySet(bracketedScores, isTiebreakOnlyFormat) {
+    if (isTiebreakOnlyFormat) {
+        return {
+            side1Score: bracketedScores[0],
+            side2Score: bracketedScores[1],
+            winningSide: determineWinningSide(bracketedScores[0], bracketedScores[1]),
+        };
+    }
+    return {
+        side1TiebreakScore: bracketedScores[0],
+        side2TiebreakScore: bracketedScores[1],
+        winningSide: determineWinningSide(bracketedScores[0], bracketedScores[1]),
+    };
+}
 function parseScoreString({ tiebreakTo = 7, scoreString = '', matchUpFormat }) {
     let parsedFormat;
     let bestOfSets = 3;
     if (matchUpFormat) {
         try {
             parsedFormat = parse(matchUpFormat);
-            const bestOfMatch = matchUpFormat?.match(/SET(\d+)/)?.[1];
+            const bestOfMatch = /SET(\d+)/.exec(matchUpFormat)?.[1];
             bestOfSets = bestOfMatch ? Number.parseInt(bestOfMatch) : 3;
         }
-        catch (_e) {
+        catch {
         }
     }
     return scoreString
         ?.split(' ')
         .filter(Boolean)
         .map((set, index) => parseSet({ set, setNumber: index + 1 }));
+    function checkIsTiebreakOnlyFormat(setNumber, isTiebreakOnlySet) {
+        if (!parsedFormat || !isTiebreakOnlySet)
+            return false;
+        const isDecidingSet = setNumber === bestOfSets;
+        const setFormat = isDecidingSet && parsedFormat.finalSetFormat ? parsedFormat.finalSetFormat : parsedFormat.setFormat;
+        if (!setFormat)
+            return false;
+        const tiebreakSetTo = setFormat.tiebreakSet?.tiebreakTo;
+        const regularSetTo = setFormat.setTo;
+        return !!tiebreakSetTo && !regularSetTo;
+    }
+    function getTiebreakToForSet(setNumber) {
+        if (!parsedFormat)
+            return tiebreakTo;
+        const isDecidingSet = setNumber === bestOfSets;
+        const setFormat = isDecidingSet && parsedFormat.finalSetFormat ? parsedFormat.finalSetFormat : parsedFormat.setFormat;
+        return setFormat?.tiebreakFormat?.tiebreakTo ?? tiebreakTo;
+    }
+    function parseTiebreakGame(tiebreakMatch, winningSide, setNumber) {
+        const setTiebreakLowScore = tiebreakMatch[1];
+        const setSpecificTiebreakTo = getTiebreakToForSet(setNumber);
+        const side1TiebreakPerspective = getTiebreakComplement({
+            lowValue: setTiebreakLowScore,
+            isSide1: winningSide === 2,
+            tiebreakTo: setSpecificTiebreakTo,
+        });
+        if (Array.isArray(side1TiebreakPerspective)) {
+            return [side1TiebreakPerspective[0], side1TiebreakPerspective[1]];
+        }
+        return [undefined, undefined];
+    }
+    function parseRegularSet(set, tiebreak, bracketed, setNumber) {
+        const setString = (tiebreak && set.replace(tiebreak[0], '')) || (bracketed && set.replace(bracketed[0], '')) || set;
+        const setScores = setString.split('-').map((score) => Number.parseInt(score));
+        const side1Score = setScores[0];
+        const side2Score = setScores[1];
+        const winningSide = determineWinningSide(side1Score, side2Score);
+        let side1TiebreakScore;
+        let side2TiebreakScore;
+        if (tiebreak) {
+            [side1TiebreakScore, side2TiebreakScore] = parseTiebreakGame(tiebreak, winningSide, setNumber);
+        }
+        if (bracketed) {
+            const matchTiebreakScores = bracketed[1].split('-').map((score) => Number.parseInt(score));
+            side1TiebreakScore = matchTiebreakScores[0];
+            side2TiebreakScore = matchTiebreakScores[1];
+        }
+        return {
+            side1Score,
+            side2Score,
+            side1TiebreakScore,
+            side2TiebreakScore,
+            winningSide,
+        };
+    }
     function parseSet({ set, setNumber }) {
         const inParentheses = /\(([^)]+)\)/;
         const inBrackets = /\[([^\]]+)\]/;
         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;
-        let side2TiebreakScore;
-        let winningSide;
+        const isTiebreakOnlyFormat = checkIsTiebreakOnlyFormat(setNumber, !!isTiebreakOnlySet);
+        let result;
         if (isTiebreakOnlySet) {
-            const bracketedScores = bracketed[1].split('-').map((score) => parseInt(score));
-            if (isTiebreakOnlyFormat) {
-                side1Score = bracketedScores[0];
-                side2Score = bracketedScores[1];
-                winningSide = (side1Score > side2Score && 1) || (side1Score < side2Score && 2) || undefined;
-            }
-            else {
-                side1TiebreakScore = bracketedScores[0];
-                side2TiebreakScore = bracketedScores[1];
-                winningSide =
-                    (side1TiebreakScore > side2TiebreakScore && 1) || (side1TiebreakScore < side2TiebreakScore && 2) || undefined;
-            }
+            const bracketedScores = bracketed[1].split('-').map((score) => Number.parseInt(score));
+            result = parseTiebreakOnlySet(bracketedScores, isTiebreakOnlyFormat);
         }
         else {
-            const setString = (tiebreak && set.replace(tiebreak[0], '')) || (bracketed && set.replace(bracketed[0], '')) || set;
-            const setScores = setString.split('-').map((score) => Number.parseInt(score));
-            side1Score = setScores[0];
-            side2Score = setScores[1];
-            winningSide = (side1Score > side2Score && 1) || (side1Score < side2Score && 2) || undefined;
-            if (tiebreak) {
-                const setTiebreakLowScore = tiebreak[1];
-                let setSpecificTiebreakTo = tiebreakTo;
-                if (parsedFormat) {
-                    const isDecidingSet = setNumber === bestOfSets;
-                    const setFormat = isDecidingSet && parsedFormat.finalSetFormat ? parsedFormat.finalSetFormat : parsedFormat.setFormat;
-                    if (setFormat?.tiebreakFormat?.tiebreakTo) {
-                        setSpecificTiebreakTo = setFormat.tiebreakFormat.tiebreakTo;
-                    }
-                }
-                const side1TiebreakPerspective = getTiebreakComplement({
-                    lowValue: setTiebreakLowScore,
-                    isSide1: winningSide === 2,
-                    tiebreakTo: setSpecificTiebreakTo,
-                });
-                if (Array.isArray(side1TiebreakPerspective)) {
-                    [side1TiebreakScore, side2TiebreakScore] = side1TiebreakPerspective;
-                }
-            }
-            if (bracketed && !isTiebreakOnlySet) {
-                const matchTiebreakScores = bracketed[1].split('-').map((score) => Number.parseInt(score));
-                side1TiebreakScore = matchTiebreakScores[0];
-                side2TiebreakScore = matchTiebreakScores[1];
-            }
+            result = parseRegularSet(set, tiebreak, bracketed, setNumber);
         }
         return {
-            side1Score,
-            side2Score,
-            side1TiebreakScore,
-            side2TiebreakScore,
-            winningSide,
+            side1Score: result.side1Score,
+            side2Score: result.side2Score,
+            side1TiebreakScore: result.side1TiebreakScore,
+            side2TiebreakScore: result.side2TiebreakScore,
+            winningSide: result.winningSide,
             setNumber,
         };
     }
@@ -47221,6 +47269,67 @@ var index$9 = {
     validMatchUps: validMatchUps
 };
 
+function inferWinningSideFromAggregate(neutralParsedSets) {
+    const aggregateTotals = neutralParsedSets.reduce((totals, set) => {
+        if (set.side1Score !== undefined || set.side2Score !== undefined) {
+            totals.side1 += set.side1Score ?? 0;
+            totals.side2 += set.side2Score ?? 0;
+        }
+        return totals;
+    }, { side1: 0, side2: 0 });
+    if (aggregateTotals.side1 > aggregateTotals.side2)
+        return 1;
+    if (aggregateTotals.side2 > aggregateTotals.side1)
+        return 2;
+    const tiebreakSet = neutralParsedSets.find((set) => set.side1TiebreakScore !== undefined || set.side2TiebreakScore !== undefined);
+    return tiebreakSet?.winningSide;
+}
+function inferWinningSideFromSets(neutralParsedSets) {
+    const setsWon = { side1: 0, side2: 0 };
+    neutralParsedSets.forEach((set) => {
+        if (set.winningSide === 1)
+            setsWon.side1++;
+        else if (set.winningSide === 2)
+            setsWon.side2++;
+    });
+    if (setsWon.side1 > setsWon.side2)
+        return 1;
+    if (setsWon.side2 > setsWon.side1)
+        return 2;
+    return undefined;
+}
+function inferWinningSide(winningSide, matchUpFormat, neutralParsedSets) {
+    if (winningSide || !matchUpFormat || !neutralParsedSets)
+        return winningSide;
+    const parsedFormat = parse(matchUpFormat);
+    const isAggregateScoring = parsedFormat?.setFormat?.based === 'A' || parsedFormat?.finalSetFormat?.based === 'A';
+    return isAggregateScoring
+        ? inferWinningSideFromAggregate(neutralParsedSets)
+        : inferWinningSideFromSets(neutralParsedSets);
+}
+function generateScoreForSideOrder(scoreString, matchUpFormat, setTBlast) {
+    const sets = parseScoreString({ scoreString, matchUpFormat });
+    return {
+        sets,
+        scoreStringSide1: generateScoreString({ sets, matchUpFormat, setTBlast }),
+        scoreStringSide2: generateScoreString({ sets, reversed: true, matchUpFormat, setTBlast }),
+    };
+}
+function generateScoreForWinnerOrder(neutralParsedSets, inferredWinningSide, matchUpFormat, setTBlast) {
+    const winningScoreString = generateScoreString({ sets: neutralParsedSets, matchUpFormat, setTBlast });
+    const losingScoreString = generateScoreString({ sets: neutralParsedSets, reversed: true, matchUpFormat, setTBlast });
+    if (typeof winningScoreString !== 'string')
+        return winningScoreString;
+    if (typeof losingScoreString !== 'string')
+        return losingScoreString;
+    const scoreStringSide1 = inferredWinningSide === 2 ? losingScoreString : winningScoreString;
+    const scoreStringSide2 = inferredWinningSide === 2 ? winningScoreString : losingScoreString;
+    return {
+        sets: parseScoreString({ scoreString: scoreStringSide1, matchUpFormat }),
+        scoreStringSide1,
+        scoreStringSide2,
+    };
+}
 function generateOutcomeFromScoreString(params) {
     const { matchUpFormat, matchUpStatus, winningSide, scoreString, setTBlast } = params;
     if (!scoreString)
@@ -47235,45 +47344,12 @@ function generateOutcomeFromScoreString(params) {
         return { error: INVALID_VALUES, winningSide };
     const neutralParsedSets = scoreString && parseScoreString({ scoreString, matchUpFormat });
     const isBracketNotation = scoreString?.trim().startsWith('[');
-    let inferredWinningSide = winningSide;
-    if (!inferredWinningSide && matchUpFormat && neutralParsedSets) {
-        const setsWon = { side1: 0, side2: 0 };
-        neutralParsedSets.forEach((set) => {
-            if (set.winningSide === 1)
-                setsWon.side1++;
-            else if (set.winningSide === 2)
-                setsWon.side2++;
-        });
-        if (setsWon.side1 > setsWon.side2)
-            inferredWinningSide = 1;
-        else if (setsWon.side2 > setsWon.side1)
-            inferredWinningSide = 2;
-    }
-    const score = {};
-    const winningScoreString = generateScoreString({
-        sets: neutralParsedSets,
-        matchUpFormat,
-        setTBlast,
-    });
-    const losingScoreString = generateScoreString({
-        sets: neutralParsedSets,
-        reversed: true,
-        matchUpFormat,
-        setTBlast,
-    });
-    if (isBracketNotation) {
-        score.scoreStringSide1 = winningScoreString;
-        score.scoreStringSide2 = losingScoreString;
-    }
-    else if (inferredWinningSide === 2) {
-        score.scoreStringSide1 = losingScoreString;
-        score.scoreStringSide2 = winningScoreString;
-    }
-    else {
-        score.scoreStringSide1 = winningScoreString;
-        score.scoreStringSide2 = losingScoreString;
-    }
-    score.sets = parseScoreString({ scoreString: score.scoreStringSide1, matchUpFormat });
+    const inferredWinningSide = inferWinningSide(winningSide, matchUpFormat, neutralParsedSets);
+    const parsedFormat = parse(matchUpFormat);
+    const isAggregateScoring = parsedFormat?.setFormat?.based === 'A' || parsedFormat?.finalSetFormat?.based === 'A';
+    const score = isBracketNotation || isAggregateScoring
+        ? generateScoreForSideOrder(scoreString, matchUpFormat, setTBlast)
+        : generateScoreForWinnerOrder(neutralParsedSets, inferredWinningSide, matchUpFormat, setTBlast);
     return definedAttributes({
         outcome: {
             matchUpStatus,