tods-competition-factory 2.2.42 → 2.2.45

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

@@ -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 = {
@@ -4894,6 +4894,12 @@ declare function removeSeeding({ tournamentRecord, drawDefinition, entryStatuses
     event: any;
     stage: any;
 }): ResultType | {
+    error: {
+        message: string;
+        code: string;
+    };
+    info: string;
+} | {
     success: boolean;
     error?: undefined;
     info?: undefined;
@@ -9964,6 +9970,8 @@ type ParsedSetString = {
     side1Score?: number;
     side2Score?: number;
     setNumber: number;
+    NoAD?: boolean;
+    tiebreakSet?: boolean;
 };
 declare function parseScoreString({ tiebreakTo, scoreString, matchUpFormat }: ParseScoreArgs): ParsedSetString[];
 

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.2.42';
+    return '2.2.45';
 }
 
 const SINGLES_MATCHUP = 'SINGLES';
@@ -10345,7 +10345,7 @@ function addMatchUpContext({ scheduleVisibilityFilters, sourceDrawPositionRanges
     const sourceDrawPositionRoundRanges = sourceDrawPositionRanges?.[roundNumber];
     const matchUpCategory = collectionDefinition?.category
         ? {
-            ...(context?.category || {}),
+            ...context?.category,
             ...collectionDefinition.category,
         }
         : (context?.category ?? event?.category);
@@ -10363,7 +10363,7 @@ function addMatchUpContext({ scheduleVisibilityFilters, sourceDrawPositionRanges
         ...onlyDefined(context),
         ...onlyDefined({
             matchUpFormat: matchUpType === TEAM$1 ? undefined : matchUpFormat,
-            tieFormat: matchUpType !== TEAM$1 ? undefined : tieFormat,
+            tieFormat: matchUpType === TEAM$1 ? tieFormat : undefined,
             gender: collectionDefinition?.gender ?? event?.gender,
             endDate: matchUp.endDate ?? endDate,
             discipline: event?.discipline,
@@ -10404,16 +10404,19 @@ function addMatchUpContext({ scheduleVisibilityFilters, sourceDrawPositionRanges
                 .sort((a, b) => a.setNumber - b.setNumber)
                 .map((set, i) => {
                 const setNumber = i + 1;
-                if (setNumber === bestOf) {
-                    if (finalSetFormat?.tiebreakSet || finalSetFormat?.timed)
-                        set.tiebreakSet = true;
-                }
-                else if (setFormat?.tiebreakSet || setFormat?.timed) {
+                const isDecidingSet = setNumber === bestOf;
+                const currentSetFormat = isDecidingSet && finalSetFormat ? finalSetFormat : setFormat;
+                const isTiebreakOnly = currentSetFormat?.tiebreakSet && !currentSetFormat?.timed;
+                const isTimed = currentSetFormat?.timed;
+                if (isTiebreakOnly) {
                     set.tiebreakSet = true;
+                    if ([1, 2].includes(set.winningSide)) {
+                        set.side1Score = set.winningSide === 1 ? 1 : 0;
+                        set.side2Score = set.winningSide === 2 ? 1 : 0;
+                    }
                 }
-                if (set.tiebreakSet && [1, 2].includes(set.winningSide)) {
-                    set.side1Score = set.winningSide === 1 ? 1 : 0;
-                    set.side2Score = set.winningSide === 2 ? 1 : 0;
+                else if (isTimed) {
+                    set.timed = true;
                 }
                 return set;
             });
@@ -21622,7 +21625,7 @@ function processPlayoffGroups({ requireSequential = true, playoffMatchUpFormat,
     }
     for (const playoffGroup of playoffGroups) {
         const finishingPositions = playoffGroup.finishingPositions;
-        const positionsPlayedOff = positionRangeMap && finishingPositions.map((p) => positionRangeMap[p]?.finishingPositions).flat();
+        const positionsPlayedOff = positionRangeMap && finishingPositions.flatMap((p) => positionRangeMap[p]?.finishingPositions ?? []);
         const participantsInDraw = groupCount * finishingPositions.length;
         const drawSize = nextPowerOf2(participantsInDraw);
         const playoffDrawType = (drawSize === 2 && SINGLE_ELIMINATION) || playoffGroup.drawType || SINGLE_ELIMINATION;
@@ -32436,6 +32439,62 @@ function validateMatchUpScore(sets, matchUpFormat, matchUpStatus) {
     return { isValid: true };
 }
 
+function validateTiebreak(tiebreakFormat, side1TiebreakScore, side2TiebreakScore, setWinningSide, isLastSet, irregularEnding) {
+    const { tiebreakTo, NoAD } = tiebreakFormat || {};
+    const maxTiebreakScore = Math.max(side1TiebreakScore ?? 0, side2TiebreakScore ?? 0);
+    if (NoAD && maxTiebreakScore > tiebreakTo)
+        return false;
+    if (maxTiebreakScore < tiebreakTo && setWinningSide) {
+        if (isLastSet && !irregularEnding)
+            return false;
+        if (!isLastSet)
+            return false;
+    }
+    return true;
+}
+function validateSet(set, i, matchUpScoringFormat, totalSets, isLastSet, irregularEnding) {
+    const setNumber = i + 1;
+    const isFinalSet = setNumber === totalSets;
+    const { side1Score, side2Score, side1TiebreakScore, side2TiebreakScore, winningSide: setWinningSide } = set;
+    const maxSetScore = Math.max(side1Score ?? 0, side2Score ?? 0);
+    const hasTiebreak = side1TiebreakScore ?? side2TiebreakScore;
+    const { finalSetFormat, setFormat } = matchUpScoringFormat;
+    const setValues = isFinalSet ? finalSetFormat || setFormat : setFormat;
+    if (hasTiebreak) {
+        const isValidTiebreak = validateTiebreak(setValues?.tiebreakFormat, side1TiebreakScore, side2TiebreakScore, setWinningSide, isLastSet, irregularEnding);
+        if (!isValidTiebreak)
+            return false;
+    }
+    if (!setValues.setTo)
+        return true;
+    const excessiveSetScore = !setValues.noTiebreak && maxSetScore > setValues.setTo + 1;
+    return !excessiveSetScore;
+}
+function calculateAggregateWinner(sets) {
+    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]) {
+        return 1;
+    }
+    else if (aggregateTotals[1] > aggregateTotals[0]) {
+        return 2;
+    }
+    else {
+        const tiebreakSet = sets.find((set) => set.side1TiebreakScore !== undefined || set.side2TiebreakScore !== undefined);
+        return tiebreakSet?.winningSide;
+    }
+}
+function calculateStandardWinner(maxSetsCount, setsToWin, maxSetsInstances, setsWinCounts, matchUpFormat) {
+    return (((!matchUpFormat || maxSetsCount === setsToWin) &&
+        maxSetsInstances === 1 &&
+        setsWinCounts.indexOf(maxSetsCount) + 1) ||
+        undefined);
+}
 function analyzeScore({ existingMatchUpStatus, matchUpFormat, matchUpStatus, winningSide, score, }) {
     const sets = score?.sets ?? [];
     const completedSets = sets?.filter((set) => set?.winningSide) || [];
@@ -32457,71 +32516,23 @@ function analyzeScore({ existingMatchUpStatus, matchUpFormat, matchUpStatus, win
     const maxSetsCount = Math.max(...setsWinCounts);
     const maxSetsInstances = instanceCount(setsWinCounts)[maxSetsCount];
     const timed = matchUpScoringFormat?.setFormat?.timed || matchUpScoringFormat?.finalSetFormat?.timed;
-    const bestOf = matchUpScoringFormat?.bestOf;
-    const setsToWin = (bestOf && Math.ceil(bestOf / 2)) || 1;
+    const totalSets = matchUpScoringFormat?.bestOf || matchUpScoringFormat?.exactly;
+    const setsToWin = (totalSets && Math.ceil(totalSets / 2)) || 1;
     const relevantMatchUpStatus = matchUpStatus ?? existingMatchUpStatus;
-    const irregularEnding = relevantMatchUpStatus && [DEFAULTED, RETIRED$1, WALKOVER$2].includes(relevantMatchUpStatus);
+    const irregularEnding = !!(relevantMatchUpStatus && [DEFAULTED, RETIRED$1, WALKOVER$2].includes(relevantMatchUpStatus));
     const validSets = !matchUpScoringFormat ||
         !sets.length ||
-        sets.every((set, i) => {
-            const setNumber = i + 1;
-            const isFinalSet = setNumber === bestOf;
-            const isLastSet = setNumber === sets.length;
-            const { side1Score, side2Score, side1TiebreakScore, side2TiebreakScore, winningSide: setWinningSide } = set;
-            const maxSetScore = Math.max(side1Score ?? 0, side2Score ?? 0);
-            const hasTiebreak = side1TiebreakScore ?? side2TiebreakScore;
-            const { finalSetFormat, setFormat } = matchUpScoringFormat;
-            const setValues = isFinalSet ? finalSetFormat || setFormat : setFormat;
-            if (hasTiebreak) {
-                const { tiebreakTo, NoAD } = setValues?.tiebreakFormat || {};
-                const maxTiebreakScore = Math.max(side1TiebreakScore ?? 0, side2TiebreakScore ?? 0);
-                if (NoAD && maxTiebreakScore > tiebreakTo)
-                    return false;
-                if (maxTiebreakScore < tiebreakTo && setWinningSide) {
-                    if (isLastSet && !irregularEnding)
-                        return false;
-                    if (!isLastSet)
-                        return false;
-                }
-            }
-            if (!setValues.setTo)
-                return true;
-            const excessiveSetScore = !setValues.noTiebreak && maxSetScore > setValues.setTo + 1;
-            return !excessiveSetScore;
-        });
+        sets.every((set, i) => validateSet(set, i, matchUpScoringFormat, totalSets ?? 0, i === sets.length - 1, irregularEnding));
     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 calculatedWinningSide = isAggregateScoring && sets.length > 0
+        ? calculateAggregateWinner(sets)
+        : calculateStandardWinner(maxSetsCount, setsToWin, maxSetsInstances, setsWinCounts, matchUpFormat);
     const valid = !!(validSets &&
         ((winningSide && isAggregateScoring && winningSide === calculatedWinningSide) ||
-            (winningSide && !isAggregateScoring && winningSideSetsCount > losingSideSetsCount && winningSide === calculatedWinningSide) ||
+            (winningSide &&
+                !isAggregateScoring &&
+                winningSideSetsCount > losingSideSetsCount &&
+                winningSide === calculatedWinningSide) ||
             (winningSide && irregularEnding) ||
             (!winningSide &&
                 !calculatedWinningSide &&
@@ -32735,6 +32746,8 @@ function parseScoreString({ tiebreakTo = 7, scoreString = '', matchUpFormat }) {
         const bracketed = inBrackets.exec(set);
         const isTiebreakOnlySet = set?.startsWith('[') && bracketed;
         const isTiebreakOnlyFormat = checkIsTiebreakOnlyFormat(setNumber, !!isTiebreakOnlySet);
+        const setSpecificTiebreakTo = getTiebreakToForSet(setNumber);
+        const isNoAD = isTiebreakOnlyFormat && setSpecificTiebreakTo === 1;
         let result;
         if (isTiebreakOnlySet) {
             const bracketedScores = bracketed[1].split('-').map((score) => Number.parseInt(score));
@@ -32750,6 +32763,8 @@ function parseScoreString({ tiebreakTo = 7, scoreString = '', matchUpFormat }) {
             side2TiebreakScore: result.side2TiebreakScore,
             winningSide: result.winningSide,
             setNumber,
+            ...(isNoAD && { NoAD: true }),
+            ...(isTiebreakOnlyFormat && { tiebreakSet: true }),
         };
     }
 }
@@ -59605,7 +59620,7 @@ async function asyncExecutionQueue(engine, directives, rollbackOnError) {
         if (!methods[methodName])
             return logMethodNotFound({ methodName, start, params });
         if (pipe) {
-            const lastResult = results[results.length - 1];
+            const lastResult = results.at(-1);
             const pipeKeys = Object.keys(pipe);
             for (const pipeKey of pipeKeys) {
                 if (lastResult[pipeKey])
@@ -59787,7 +59802,7 @@ function executionQueue(engine, directives, rollbackOnError) {
         if (!methods[methodName])
             return logMethodNotFound({ methodName, start, params });
         if (pipe) {
-            const lastResult = results[results.length - 1];
+            const lastResult = results.at(-1);
             const pipeKeys = Object.keys(pipe);
             for (const pipeKey of pipeKeys) {
                 if (lastResult[pipeKey])