tods-competition-factory 2.2.39 → 2.2.40

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.40';
 }
 
 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 }) {
@@ -32429,12 +32462,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 &&