tods-competition-factory 2.2.39 → 2.2.41

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 = {

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.2.39';
+    return '2.2.41';
 }
 
 const SINGLES_MATCHUP = 'SINGLES';
@@ -1992,8 +1992,15 @@ function getNumber$1(formatstring) {
 }
 function timedSetFormat(matchUpFormatObject) {
     let value = `T${matchUpFormatObject.minutes}`;
-    if (matchUpFormatObject.based)
-        value += matchUpFormatObject.based;
+    if (matchUpFormatObject.based === 'A') {
+        value += 'A';
+    }
+    else if (matchUpFormatObject.based === 'P') {
+        value += 'P';
+    }
+    if (matchUpFormatObject.tiebreakFormat?.tiebreakTo) {
+        value += `/TB${matchUpFormatObject.tiebreakFormat.tiebreakTo}`;
+    }
     if (matchUpFormatObject.modifier)
         value += `@${matchUpFormatObject.modifier}`;
     return value;
@@ -2103,44 +2110,56 @@ function setsMatch(formatstring) {
         return result;
 }
 function parseSetFormat(formatstring) {
-    if (formatstring?.[1] === ':') {
-        const parts = formatstring.split(':');
-        const setType = setTypes$1[parts[0]];
-        const setFormatString = parts[1];
-        if (setType && setFormatString) {
-            const isTiebreakSet = setFormatString.startsWith('TB');
-            if (isTiebreakSet) {
-                const tiebreakSet = parseTiebreakFormat(setFormatString);
-                if (tiebreakSet === false)
-                    return false;
-                return typeof tiebreakSet === 'object' ? { tiebreakSet } : undefined;
-            }
-            const timedSet = setFormatString.startsWith('T');
-            if (timedSet)
-                return parseTimedSet(setFormatString);
-            const parts = formatstring.match(/^[FS]:(\d+)([A-Za-z]*)/);
-            const NoAD = (parts && isNoAD(parts[2])) || false;
-            const validNoAD = !parts?.[2] || NoAD;
-            const setTo = parts ? getNumber(parts[1]) : undefined;
-            const tiebreakAtValue = parseTiebreakAt(setFormatString);
-            const validTiebreakAt = tiebreakAtValue !== false;
-            const tiebreakAt = (validTiebreakAt && tiebreakAtValue) || setTo;
-            const tiebreakFormat = parseTiebreakFormat(setFormatString.split('/')[1]);
-            const validTiebreak = tiebreakFormat !== false;
-            const result = { setTo };
-            if (NoAD)
-                result.NoAD = true;
-            if (tiebreakFormat) {
-                result.tiebreakFormat = tiebreakFormat;
-                result.tiebreakAt = tiebreakAt;
-            }
-            else {
-                result.noTiebreak = true;
-            }
-            return (setTo && validNoAD && validTiebreak && validTiebreakAt && result) || false;
-        }
+    if (formatstring?.[1] !== ':')
+        return undefined;
+    const parts = formatstring.split(':');
+    const setType = setTypes$1[parts[0]];
+    const setFormatString = parts[1];
+    if (!setType || !setFormatString)
+        return undefined;
+    return parseSetFormatString(formatstring, setFormatString);
+}
+function parseSetFormatString(formatstring, setFormatString) {
+    if (setFormatString.startsWith('TB')) {
+        return parseTiebreakSetFormat(setFormatString);
     }
-    return undefined;
+    if (setFormatString.startsWith('T')) {
+        return parseTimedSet(setFormatString);
+    }
+    return parseStandardSetFormat(formatstring, setFormatString);
+}
+function parseTiebreakSetFormat(setFormatString) {
+    const tiebreakSet = parseTiebreakFormat(setFormatString);
+    if (tiebreakSet === false)
+        return false;
+    return typeof tiebreakSet === 'object' ? { tiebreakSet } : undefined;
+}
+function parseStandardSetFormat(formatstring, setFormatString) {
+    const parts = /^[FS]:(\d+)([A-Za-z]*)/.exec(formatstring);
+    const NoAD = (parts && isNoAD(parts[2])) || false;
+    const validNoAD = !parts?.[2] || NoAD;
+    const setTo = parts ? getNumber(parts[1]) : undefined;
+    const tiebreakAtValue = parseTiebreakAt(setFormatString);
+    const validTiebreakAt = tiebreakAtValue !== false;
+    const tiebreakAt = (validTiebreakAt && tiebreakAtValue) || setTo;
+    const tiebreakFormat = parseTiebreakFormat(setFormatString.split('/')[1]);
+    const validTiebreak = tiebreakFormat !== false;
+    if (!setTo || !validNoAD || !validTiebreak || !validTiebreakAt)
+        return false;
+    return buildSetFormatResult(setTo, NoAD, tiebreakFormat, tiebreakAt);
+}
+function buildSetFormatResult(setTo, NoAD, tiebreakFormat, tiebreakAt) {
+    const result = { setTo };
+    if (NoAD)
+        result.NoAD = true;
+    if (tiebreakFormat) {
+        result.tiebreakFormat = tiebreakFormat;
+        result.tiebreakAt = tiebreakAt;
+    }
+    else {
+        result.noTiebreak = true;
+    }
+    return result;
 }
 function parseTiebreakAt(setFormatString, expectNumber = true) {
     const tiebreakAtValue = setFormatString?.indexOf('@') > 0 && setFormatString.split('@');
@@ -2151,59 +2170,73 @@ function parseTiebreakAt(setFormatString, expectNumber = true) {
     return undefined;
 }
 function parseTiebreakFormat(formatstring) {
-    if (formatstring) {
-        if (formatstring.startsWith('TB')) {
-            const modifier = parseTiebreakAt(formatstring, false);
-            const parts = formatstring.match(/^TB(\d+)([A-Za-z]*)/);
-            const tiebreakToString = parts?.[1];
-            const NoAD = parts && isNoAD(parts[2]);
-            const validNoAD = !parts?.[2] || NoAD;
-            const tiebreakTo = getNumber(tiebreakToString);
-            if (tiebreakTo && validNoAD) {
-                const result = { tiebreakTo };
-                if (modifier && typeof modifier === 'string' && !isConvertableInteger(modifier)) {
-                    result.modifier = modifier;
-                }
-                if (NoAD)
-                    result.NoAD = true;
-                return result;
-            }
-            else {
-                return false;
-            }
-        }
-        else {
-            return false;
-        }
+    if (!formatstring)
+        return undefined;
+    if (!formatstring.startsWith('TB'))
+        return false;
+    return parseTiebreakDetails(formatstring);
+}
+function parseTiebreakDetails(formatstring) {
+    const modifier = parseTiebreakAt(formatstring, false);
+    const parts = /^TB(\d+)([A-Za-z]*)/.exec(formatstring);
+    const tiebreakToString = parts?.[1];
+    const NoAD = parts && isNoAD(parts[2]);
+    const validNoAD = !parts?.[2] || NoAD;
+    const tiebreakTo = getNumber(tiebreakToString);
+    if (!tiebreakTo || !validNoAD)
+        return false;
+    const result = { tiebreakTo };
+    if (modifier && typeof modifier === 'string' && !isConvertableInteger(modifier)) {
+        result.modifier = modifier;
     }
-    return undefined;
+    if (NoAD)
+        result.NoAD = true;
+    return result;
 }
 function parseTimedSet(formatstring) {
     const timestring = formatstring.slice(1);
-    const parts = timestring.match(/^(\d+)(@?[A-Za-z]*)/);
+    const parts = /^(\d+)([PGA])?(?:\/TB(\d+))?(@?[A-Za-z]*)?/.exec(timestring);
     const minutes = getNumber(parts?.[1]);
     if (!minutes)
         return;
     const setFormat = { timed: true, minutes };
-    const based = parts?.[2];
-    const validModifier = [undefined, 'P', 'G'].includes(based);
-    if (based && !validModifier) {
-        const modifier = timestring.match(/^(\d+)(@)([A-Za-z]+)$/)?.[3];
+    const scoringMethod = parts?.[2];
+    if (scoringMethod === 'A') {
+        setFormat.based = 'A';
+    }
+    else if (scoringMethod === 'P') {
+        setFormat.based = 'P';
+    }
+    else if (scoringMethod === 'G') {
+        setFormat.based = 'G';
+    }
+    const setTiebreakTo = parts?.[3];
+    if (setTiebreakTo) {
+        const tiebreakToNumber = getNumber(setTiebreakTo);
+        if (tiebreakToNumber) {
+            setFormat.tiebreakFormat = { tiebreakTo: tiebreakToNumber };
+        }
+    }
+    const legacyModifier = parts?.[4];
+    const validModifier = [undefined, 'P', 'G', ''].includes(legacyModifier);
+    if (legacyModifier && !validModifier) {
+        const modifier = /^(\d+)([PGA])?(?:\/TB\d+)?(@)([A-Za-z]+)$/.exec(timestring)?.[4];
         if (modifier) {
             setFormat.modifier = modifier;
             return setFormat;
         }
         return;
     }
-    if (based)
-        setFormat.based = parts[2];
+    if (legacyModifier)
+        setFormat.based = legacyModifier;
     return setFormat;
 }
 function isNoAD(formatstring) {
-    return formatstring && formatstring.indexOf(NOAD) >= 0;
+    return formatstring?.includes(NOAD);
 }
 function getNumber(formatstring) {
-    return !isNaN(Number(formatstring)) ? Number(formatstring) : 0;
+    const num = Number(formatstring);
+    return Number.isNaN(num) ? 0 : num;
 }
 
 function isValidMatchUpFormat({ matchUpFormat }) {
@@ -32333,6 +32366,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;
@@ -32429,12 +32480,39 @@ function analyzeScore({ existingMatchUpStatus, matchUpFormat, matchUpStatus, win
             const excessiveSetScore = !setValues.noTiebreak && maxSetScore > setValues.setTo + 1;
             return !excessiveSetScore;
         });
-    const calculatedWinningSide = ((!matchUpFormat || maxSetsCount === setsToWin) &&
-        maxSetsInstances === 1 &&
-        setsWinCounts.indexOf(maxSetsCount) + 1) ||
-        undefined;
+    const isAggregateScoring = matchUpScoringFormat?.setFormat?.based === 'A' || matchUpScoringFormat?.finalSetFormat?.based === 'A';
+    let calculatedWinningSide;
+    if (isAggregateScoring && sets.length > 0) {
+        const aggregateTotals = sets.reduce((totals, set) => {
+            if (set.side1Score !== undefined || set.side2Score !== undefined) {
+                totals[0] += set.side1Score ?? 0;
+                totals[1] += set.side2Score ?? 0;
+            }
+            return totals;
+        }, [0, 0]);
+        if (aggregateTotals[0] > aggregateTotals[1]) {
+            calculatedWinningSide = 1;
+        }
+        else if (aggregateTotals[1] > aggregateTotals[0]) {
+            calculatedWinningSide = 2;
+        }
+        else {
+            const tiebreakSet = sets.find((set) => set.side1TiebreakScore !== undefined || set.side2TiebreakScore !== undefined);
+            if (tiebreakSet) {
+                calculatedWinningSide = tiebreakSet.winningSide;
+            }
+        }
+    }
+    else {
+        calculatedWinningSide =
+            ((!matchUpFormat || maxSetsCount === setsToWin) &&
+                maxSetsInstances === 1 &&
+                setsWinCounts.indexOf(maxSetsCount) + 1) ||
+                undefined;
+    }
     const valid = !!(validSets &&
-        ((winningSide && winningSideSetsCount > losingSideSetsCount && winningSide === calculatedWinningSide) ||
+        ((winningSide && isAggregateScoring && winningSide === calculatedWinningSide) ||
+            (winningSide && !isAggregateScoring && winningSideSetsCount > losingSideSetsCount && winningSide === calculatedWinningSide) ||
             (winningSide && irregularEnding) ||
             (!winningSide &&
                 !calculatedWinningSide &&
@@ -47177,43 +47255,79 @@ function generateOutcomeFromScoreString(params) {
     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 parsedFormat = parse(matchUpFormat);
+        const isAggregateScoring = parsedFormat?.setFormat?.based === 'A' || parsedFormat?.finalSetFormat?.based === 'A';
+        if (isAggregateScoring) {
+            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)
+                inferredWinningSide = 1;
+            else if (aggregateTotals.side2 > aggregateTotals.side1)
+                inferredWinningSide = 2;
+            else {
+                const tiebreakSet = neutralParsedSets.find((set) => set.side1TiebreakScore !== undefined || set.side2TiebreakScore !== undefined);
+                if (tiebreakSet)
+                    inferredWinningSide = tiebreakSet.winningSide;
+            }
+        }
+        else {
+            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;
+    const parsedFormat = parse(matchUpFormat);
+    const isAggregateScoring = parsedFormat?.setFormat?.based === 'A' || parsedFormat?.finalSetFormat?.based === 'A';
+    if (isBracketNotation || isAggregateScoring) {
+        score.sets = parseScoreString({ scoreString, matchUpFormat });
+        score.scoreStringSide1 = generateScoreString({
+            sets: score.sets,
+            matchUpFormat,
+            setTBlast,
+        });
+        score.scoreStringSide2 = generateScoreString({
+            sets: score.sets,
+            reversed: true,
+            matchUpFormat,
+            setTBlast,
+        });
     }
     else {
-        score.scoreStringSide1 = winningScoreString;
-        score.scoreStringSide2 = losingScoreString;
+        const winningScoreString = generateScoreString({
+            sets: neutralParsedSets,
+            matchUpFormat,
+            setTBlast,
+        });
+        const losingScoreString = generateScoreString({
+            sets: neutralParsedSets,
+            reversed: true,
+            matchUpFormat,
+            setTBlast,
+        });
+        if (inferredWinningSide === 2) {
+            score.scoreStringSide1 = losingScoreString;
+            score.scoreStringSide2 = winningScoreString;
+        }
+        else {
+            score.scoreStringSide1 = winningScoreString;
+            score.scoreStringSide2 = losingScoreString;
+        }
+        score.sets = parseScoreString({ scoreString: score.scoreStringSide1, matchUpFormat });
     }
-    score.sets = parseScoreString({ scoreString: score.scoreStringSide1, matchUpFormat });
     return definedAttributes({
         outcome: {
             matchUpStatus,