tods-competition-factory 2.2.37 → 2.2.39

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.2.37';
+    return '2.2.39';
 }
 
 const SINGLES_MATCHUP = 'SINGLES';
@@ -2005,7 +2005,8 @@ function getSetFormat(matchUpFormatObject, preserveRedundant) {
     if (matchUpFormatObject.setFormat?.timed && matchUpFormatObject.simplified && setLimit === 1) {
         return timedSetFormat(matchUpFormatObject.setFormat);
     }
-    const setLimitCode = (setLimit && `${SET}${setLimit}`) || '';
+    const exactlySuffix = exactly && exactly !== 1 ? 'X' : '';
+    const setLimitCode = (setLimit && `${SET}${setLimit}${exactlySuffix}`) || '';
     const setCountValue = stringifySet(matchUpFormatObject.setFormat, preserveRedundant);
     const setCode = (setCountValue && `S:${setCountValue}`) || '';
     const finalSetCountValue = stringifySet(matchUpFormatObject.finalSetFormat, preserveRedundant);
@@ -2079,9 +2080,12 @@ function parse(matchUpFormatCode) {
 }
 function setsMatch(formatstring) {
     const parts = formatstring.split('-');
-    const setsCount = getNumber(parts[0].slice(3));
-    const bestOf = setsCount === 1 || setsCount % 2 !== 0 ? setsCount : undefined;
-    const exactly = setsCount !== 1 && setsCount % 2 === 0 ? setsCount : undefined;
+    const setsPart = parts[0].slice(3);
+    const hasExactlySuffix = setsPart.endsWith('X');
+    const setsCountString = hasExactlySuffix ? setsPart.slice(0, -1) : setsPart;
+    const setsCount = getNumber(setsCountString);
+    const bestOf = hasExactlySuffix && setsCount !== 1 ? undefined : setsCount;
+    const exactly = hasExactlySuffix && setsCount !== 1 ? setsCount : undefined;
     const setFormat = parts && parseSetFormat(parts[1]);
     const finalSetFormat = parts && parseSetFormat(parts[2]);
     const timed = (setFormat && setFormat.timed) || (finalSetFormat && finalSetFormat.timed);
@@ -32114,7 +32118,7 @@ function tidyScore(params) {
     doProcess(processingOrder);
     let isValid = isValidPattern(score);
     if (!isValid) {
-        score = incomingScore.toString().replace(/\D/g, '');
+        score = incomingScore.toString().replaceAll(/\D/g, '');
         if (attributes?.removed) {
             attributes.removed = undefined;
         }
@@ -32147,6 +32151,179 @@ var help = {
     tidyScore: tidyScore
 };
 
+function validateTiebreakOnlySet(winnerScore, loserScore, scoreDiff, tiebreakSetTo, allowIncomplete) {
+    if (allowIncomplete) {
+        return { isValid: true };
+    }
+    if (winnerScore === 0 && loserScore === 0) {
+        return { isValid: false, error: 'Tiebreak-only set requires both scores' };
+    }
+    if (winnerScore < tiebreakSetTo) {
+        return {
+            isValid: false,
+            error: `Tiebreak-only set winner must reach at least ${tiebreakSetTo}, got ${winnerScore}`,
+        };
+    }
+    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 at ${tiebreakSetTo}-${loserScore} requires playing past ${tiebreakSetTo}`,
+        };
+    }
+    if (winnerScore > tiebreakSetTo && scoreDiff !== 2) {
+        return {
+            isValid: false,
+            error: `Tiebreak-only set past ${tiebreakSetTo} must be won by exactly 2 points, got ${winnerScore}-${loserScore}`,
+        };
+    }
+    return { isValid: true };
+}
+function validateTiebreakSetGames(winnerScore, loserScore, setTo, tiebreakAt) {
+    const expectedWinnerScore = tiebreakAt === setTo ? setTo + 1 : setTo;
+    const expectedLoserScore = tiebreakAt;
+    if (winnerScore !== expectedWinnerScore) {
+        return {
+            isValid: false,
+            error: `Tiebreak set winner must have ${expectedWinnerScore} games, got ${winnerScore}`,
+        };
+    }
+    if (loserScore !== expectedLoserScore) {
+        return {
+            isValid: false,
+            error: `Tiebreak set loser must have ${expectedLoserScore} games, got ${loserScore}`,
+        };
+    }
+    return { isValid: true };
+}
+function validateExplicitTiebreakScore(side1TiebreakScore, side2TiebreakScore, tiebreakFormat) {
+    const tbWinnerScore = Math.max(side1TiebreakScore || 0, side2TiebreakScore || 0);
+    const tbLoserScore = Math.min(side1TiebreakScore || 0, side2TiebreakScore || 0);
+    const tbDiff = tbWinnerScore - tbLoserScore;
+    const tbTo = tiebreakFormat.tiebreakTo || 7;
+    if (tbWinnerScore < tbTo) {
+        return {
+            isValid: false,
+            error: `Tiebreak winner must reach ${tbTo} points, got ${tbWinnerScore}`,
+        };
+    }
+    if (tbDiff < 2) {
+        return {
+            isValid: false,
+            error: `Tiebreak must be won by 2 points, got ${tbWinnerScore}-${tbLoserScore}`,
+        };
+    }
+    if (tbLoserScore >= tbTo - 1 && tbDiff > 2) {
+        return {
+            isValid: false,
+            error: `Tiebreak score ${tbWinnerScore}-${tbLoserScore} is invalid`,
+        };
+    }
+    return { isValid: true };
+}
+function validateTwoGameMargin(side1Score, side2Score, setTo, tiebreakAt) {
+    if (!tiebreakAt)
+        return { isValid: true };
+    if (side1Score === setTo + 1 && side2Score < setTo - 1) {
+        return {
+            isValid: false,
+            error: `With tiebreak format, if side 1 has ${setTo + 1} games, side 2 must be at least ${setTo - 1}, got ${side2Score}`,
+        };
+    }
+    if (side2Score === setTo + 1 && side1Score < setTo - 1) {
+        return {
+            isValid: false,
+            error: `With tiebreak format, if side 2 has ${setTo + 1} games, side 1 must be at least ${setTo - 1}, got ${side1Score}`,
+        };
+    }
+    return { isValid: true };
+}
+function validateRegularSetCompletion(winnerScore, loserScore, scoreDiff, setTo, tiebreakAt) {
+    if (winnerScore < setTo) {
+        return {
+            isValid: false,
+            error: `Set winner must reach ${setTo} games, got ${winnerScore}`,
+        };
+    }
+    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 && !isTiebreakWon) {
+            return {
+                isValid: false,
+                error: `When tied at ${tiebreakAt}-${tiebreakAt}, must play tiebreak. Use format like ${tiebreakAt + 1}-${tiebreakAt}(5)`,
+            };
+        }
+        const maxWinnerScore = tiebreakAt === setTo ? setTo + 1 : setTo;
+        if (winnerScore > maxWinnerScore) {
+            return {
+                isValid: false,
+                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`,
+        };
+    }
+    return { isValid: true };
+}
+function parseSetScores(set, isTiebreakOnlyFormat, hasTiebreakScores) {
+    const side1TiebreakScore = set.side1TiebreakScore;
+    const side2TiebreakScore = set.side2TiebreakScore;
+    const side1Score = isTiebreakOnlyFormat && hasTiebreakScores ? side1TiebreakScore : set.side1Score || set.side1 || 0;
+    const side2Score = isTiebreakOnlyFormat && hasTiebreakScores ? side2TiebreakScore : set.side2Score || set.side2 || 0;
+    return { side1Score, side2Score, side1TiebreakScore, side2TiebreakScore };
+}
+function validateTiebreakSet(winnerScore, loserScore, setTo, tiebreakAt, side1TiebreakScore, side2TiebreakScore, tiebreakFormat) {
+    if (setTo && tiebreakAt) {
+        const validation = validateTiebreakSetGames(winnerScore, loserScore, setTo, tiebreakAt);
+        if (!validation.isValid)
+            return validation;
+    }
+    const hasExplicitTiebreak = side1TiebreakScore !== undefined || side2TiebreakScore !== undefined;
+    if (hasExplicitTiebreak && tiebreakFormat) {
+        return validateExplicitTiebreakScore(side1TiebreakScore, side2TiebreakScore, tiebreakFormat);
+    }
+    return { isValid: true };
+}
+function validateIncompleteSet(winnerScore, loserScore, setTo) {
+    if (setTo && (winnerScore > setTo + 10 || loserScore > setTo + 10)) {
+        return {
+            isValid: false,
+            error: `Set score ${winnerScore}-${loserScore} exceeds expected range for ${setTo}-game sets`,
+        };
+    }
+    return { isValid: true };
+}
+function validateRegularSet(scores, setFormat, allowIncomplete) {
+    const { side1: side1Score, side2: side2Score, winner: winnerScore, loser: loserScore, diff: scoreDiff } = scores;
+    const { setTo, tiebreakAt } = setFormat;
+    if (setTo && tiebreakAt) {
+        const marginValidation = validateTwoGameMargin(side1Score, side2Score, setTo, tiebreakAt);
+        if (!marginValidation.isValid)
+            return marginValidation;
+    }
+    if (allowIncomplete) {
+        return validateIncompleteSet(winnerScore, loserScore, setTo);
+    }
+    if (setTo) {
+        return validateRegularSetCompletion(winnerScore, loserScore, scoreDiff, setTo, tiebreakAt);
+    }
+    return { isValid: true };
+}
 function validateSetScore(set, matchUpFormat, isDecidingSet, allowIncomplete) {
     if (!matchUpFormat)
         return { isValid: true };
@@ -32159,152 +32336,21 @@ function validateSetScore(set, matchUpFormat, isDecidingSet, allowIncomplete) {
     const { setTo, tiebreakAt, tiebreakFormat, tiebreakSet } = setFormat;
     const tiebreakSetTo = tiebreakSet?.tiebreakTo;
     const isTiebreakOnlyFormat = !!tiebreakSetTo && !setTo;
-    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 hasTiebreakScores = set.side1TiebreakScore !== undefined && set.side2TiebreakScore !== undefined;
+    const { side1Score, side2Score, side1TiebreakScore, side2TiebreakScore } = parseSetScores(set, isTiebreakOnlyFormat, hasTiebreakScores);
     const winnerScore = Math.max(side1Score, side2Score);
     const loserScore = Math.min(side1Score, side2Score);
     const scoreDiff = winnerScore - loserScore;
     if (isTiebreakOnlyFormat) {
-        if (allowIncomplete) {
-            return { isValid: true };
-        }
-        if (side1Score === 0 && side2Score === 0) {
-            return { isValid: false, error: 'Tiebreak-only set requires both scores' };
-        }
-        if (winnerScore < tiebreakSetTo) {
-            return {
-                isValid: false,
-                error: `Tiebreak-only set winner must reach at least ${tiebreakSetTo}, got ${winnerScore}`,
-            };
-        }
-        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 at ${tiebreakSetTo}-${loserScore} requires playing past ${tiebreakSetTo}`,
-            };
-        }
-        if (winnerScore > tiebreakSetTo && scoreDiff !== 2) {
-            return {
-                isValid: false,
-                error: `Tiebreak-only set past ${tiebreakSetTo} must be won by exactly 2 points, got ${winnerScore}-${loserScore}`,
-            };
-        }
-        return { isValid: true };
+        return validateTiebreakOnlySet(winnerScore, loserScore, scoreDiff, tiebreakSetTo, allowIncomplete ?? false);
     }
     const hasExplicitTiebreak = side1TiebreakScore !== undefined || side2TiebreakScore !== undefined;
     const isImplicitTiebreak = setTo && winnerScore === setTo + 1 && loserScore === setTo;
     const hasTiebreak = hasExplicitTiebreak || isImplicitTiebreak;
     if (hasTiebreak) {
-        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 ${expectedWinnerScore} games, got ${winnerScore}`,
-                };
-            }
-            if (loserScore !== expectedLoserScore) {
-                return {
-                    isValid: false,
-                    error: `Tiebreak set loser must have ${expectedLoserScore} games, got ${loserScore}`,
-                };
-            }
-        }
-        if (hasExplicitTiebreak && tiebreakFormat) {
-            const tbWinnerScore = Math.max(side1TiebreakScore || 0, side2TiebreakScore || 0);
-            const tbLoserScore = Math.min(side1TiebreakScore || 0, side2TiebreakScore || 0);
-            const tbDiff = tbWinnerScore - tbLoserScore;
-            const tbTo = tiebreakFormat.tiebreakTo || 7;
-            if (tbWinnerScore < tbTo) {
-                return {
-                    isValid: false,
-                    error: `Tiebreak winner must reach ${tbTo} points, got ${tbWinnerScore}`,
-                };
-            }
-            if (tbDiff < 2) {
-                return {
-                    isValid: false,
-                    error: `Tiebreak must be won by 2 points, got ${tbWinnerScore}-${tbLoserScore}`,
-                };
-            }
-            if (tbLoserScore >= tbTo - 1 && tbDiff > 2) {
-                return {
-                    isValid: false,
-                    error: `Tiebreak score ${tbWinnerScore}-${tbLoserScore} is invalid`,
-                };
-            }
-        }
+        return validateTiebreakSet(winnerScore, loserScore, setTo, tiebreakAt, side1TiebreakScore, side2TiebreakScore, tiebreakFormat);
     }
-    else {
-        if (setTo && tiebreakAt) {
-            if (side1Score === setTo + 1 && side2Score < setTo - 1) {
-                return {
-                    isValid: false,
-                    error: `With tiebreak format, if side 1 has ${setTo + 1} games, side 2 must be at least ${setTo - 1}, got ${side2Score}`,
-                };
-            }
-            if (side2Score === setTo + 1 && side1Score < setTo - 1) {
-                return {
-                    isValid: false,
-                    error: `With tiebreak format, if side 2 has ${setTo + 1} games, side 1 must be at least ${setTo - 1}, got ${side1Score}`,
-                };
-            }
-        }
-        if (allowIncomplete) {
-            if (setTo && (winnerScore > setTo + 10 || loserScore > setTo + 10)) {
-                return {
-                    isValid: false,
-                    error: `Set score ${winnerScore}-${loserScore} exceeds expected range for ${setTo}-game sets`,
-                };
-            }
-            return { isValid: true };
-        }
-        if (setTo && winnerScore < setTo) {
-            return {
-                isValid: false,
-                error: `Set winner must reach ${setTo} games, got ${winnerScore}`,
-            };
-        }
-        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 && !isTiebreakWon) {
-                return {
-                    isValid: false,
-                    error: `When tied at ${tiebreakAt}-${tiebreakAt}, must play tiebreak. Use format like ${tiebreakAt + 1}-${tiebreakAt}(5)`,
-                };
-            }
-            const maxWinnerScore = tiebreakAt === setTo ? setTo + 1 : setTo;
-            if (winnerScore > maxWinnerScore) {
-                return {
-                    isValid: false,
-                    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`,
-            };
-        }
-    }
-    return { isValid: true };
+    return validateRegularSet({ side1: side1Score, side2: side2Score, winner: winnerScore, loser: loserScore, diff: scoreDiff }, { setTo, tiebreakAt }, allowIncomplete);
 }
 function validateMatchUpScore(sets, matchUpFormat, matchUpStatus) {
     if (!sets || sets.length === 0) {
@@ -32566,10 +32612,18 @@ function parseScoreString({ tiebreakTo = 7, scoreString = '', matchUpFormat }) {
             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,
+                    tiebreakTo: setSpecificTiebreakTo,
                 });
                 if (Array.isArray(side1TiebreakPerspective)) {
                     [side1TiebreakScore, side2TiebreakScore] = side1TiebreakPerspective;
@@ -36501,9 +36555,9 @@ function courtGridRows({ courtPrefix = 'C|', minRowsCount, courtsData }) {
     const maxCourtOrder = courtsData?.reduce((order, court) => {
         const matchUps = court.matchUps || [];
         const courtOrder = Math.max(0, ...matchUps.map((m) => m.schedule.courtOrder || 0));
-        return courtOrder > order ? courtOrder : order;
+        return Math.max(courtOrder, order);
     }, 1);
-    const rowsCount = minRowsCount ? Math.max(minRowsCount, maxCourtOrder) : maxCourtOrder;
+    const rowsCount = Math.max(minRowsCount || 0, maxCourtOrder);
     const rowBuilder = generateRange(0, rowsCount).map((rowIndex) => ({
         matchUps: generateRange(0, courtsData.length).map((courtIndex) => {
             const courtInfo = courtsData[courtIndex];
@@ -37274,24 +37328,22 @@ function competitionScheduleMatchUps(params) {
         ({ drawIds: publishedDrawIds, detailsMap } = getCompetitionPublishedDrawDetails({ tournamentRecords }));
     }
     if (publishedDrawIds?.length) {
-        if (!params.contextFilters)
-            params.contextFilters = {};
-        if (!params.contextFilters?.drawIds) {
-            params.contextFilters.drawIds = publishedDrawIds;
+        params.contextFilters ??= {};
+        if (params.contextFilters.drawIds) {
+            params.contextFilters.drawIds = params.contextFilters.drawIds.filter((drawId) => publishedDrawIds.includes(drawId));
         }
         else {
-            params.contextFilters.drawIds = params.contextFilters.drawIds.filter((drawId) => publishedDrawIds.includes(drawId));
+            params.contextFilters.drawIds = publishedDrawIds;
         }
     }
     if (tournamentPublishStatus?.eventIds?.length) {
-        if (!params.matchUpFilters)
-            params.matchUpFilters = {};
+        params.matchUpFilters ??= {};
         if (params.matchUpFilters?.eventIds) {
-            if (!params.matchUpFilters.eventIds.length) {
-                params.matchUpFilters.eventIds = tournamentPublishStatus.eventIds;
+            if (params.matchUpFilters.eventIds.length) {
+                params.matchUpFilters.eventIds = params.matchUpFilters.eventIds.filter((eventId) => tournamentPublishStatus.eventIds.includes(eventId));
             }
             else {
-                params.matchUpFilters.eventIds = params.matchUpFilters.eventIds.filter((eventId) => tournamentPublishStatus.eventIds.includes(eventId));
+                params.matchUpFilters.eventIds = tournamentPublishStatus.eventIds;
             }
         }
         else {
@@ -37299,14 +37351,13 @@ function competitionScheduleMatchUps(params) {
         }
     }
     if (tournamentPublishStatus?.scheduledDates?.length) {
-        if (!params.matchUpFilters)
-            params.matchUpFilters = {};
+        params.matchUpFilters ??= {};
         if (params.matchUpFilters.scheduledDates) {
-            if (!params.matchUpFilters.scheduledDates.length) {
-                params.matchUpFilters.scheduledDates = tournamentPublishStatus.scheduledDates;
+            if (params.matchUpFilters.scheduledDates.length) {
+                params.matchUpFilters.scheduledDates = params.matchUpFilters.scheduledDates.filter((scheduledDate) => tournamentPublishStatus.scheduledDates.includes(scheduledDate));
             }
             else {
-                params.matchUpFilters.scheduledDates = params.matchUpFilters.scheduledDates.filter((scheduledDate) => tournamentPublishStatus.scheduledDates.includes(scheduledDate));
+                params.matchUpFilters.scheduledDates = tournamentPublishStatus.scheduledDates;
             }
         }
         else {
@@ -37314,8 +37365,7 @@ function competitionScheduleMatchUps(params) {
         }
     }
     if (alwaysReturnCompleted) {
-        if (!params.matchUpFilters)
-            params.matchUpFilters = {};
+        params.matchUpFilters ??= {};
         if (params.matchUpFilters?.excludeMatchUpStatuses?.length) {
             if (!params.matchUpFilters.excludeMatchUpStatuses.includes(COMPLETED$1)) {
                 params.matchUpFilters.excludeMatchUpStatuses.push(COMPLETED$1);
@@ -37382,7 +37432,7 @@ function competitionScheduleMatchUps(params) {
     };
     if (withCourtGridRows) {
         const { rows, courtPrefix } = courtGridRows({
-            minRowsCount: minCourtGridRows,
+            minRowsCount: Math.max(minCourtGridRows || 0, dateMatchUps.length || 0),
             courtsData,
         });
         result.courtPrefix = courtPrefix;
@@ -51968,7 +52018,7 @@ function generateTournamentRecord(params) {
             return result;
     }
     if (params.drawProfiles) {
-        const result = processDrawProfiles({
+        const result = processDrawProfiles$1({
             allUniqueParticipantIds,
             ratingsParameters: ratingsParameters$1,
             tournamentRecord,
@@ -51980,7 +52030,7 @@ function generateTournamentRecord(params) {
             return result;
     }
     if (params.eventProfiles) {
-        const result = processEventProfiles({
+        const result = processEventProfiles$1({
             allUniqueParticipantIds,
             ratingsParameters: ratingsParameters$1,
             tournamentRecord,
@@ -52005,7 +52055,7 @@ function generateTournamentRecord(params) {
         drawIds,
     });
 }
-function processDrawProfiles(params) {
+function processDrawProfiles$1(params) {
     const { tournamentRecord, drawProfiles, allUniqueParticipantIds, eventIds, drawIds } = params;
     let drawIndex = 0;
     for (const drawProfile of drawProfiles) {
@@ -52037,7 +52087,7 @@ function processDrawProfiles(params) {
         drawIndex += 1;
     }
 }
-function processEventProfiles(params) {
+function processEventProfiles$1(params) {
     const { eventProfiles, allUniqueParticipantIds, eventIds, drawIds } = params;
     let eventIndex = 0;
     for (const eventProfile of eventProfiles) {
@@ -52364,164 +52414,150 @@ function generatePairParticipantName({ individualParticipantIds, individualParti
     return participantName;
 }
 
-function modifyTournamentRecord(params) {
-    const { ratingsParameters: ratingsParameters$1 = ratingsParameters, participantsProfile = {}, matchUpStatusProfile, completeAllMatchUps, autoEntryPositions, hydrateCollections, randomWinningSide, schedulingProfile, tournamentRecord, autoSchedule, eventProfiles, periodLength, venueProfiles, drawProfiles, isMock, uuids, } = params;
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    const allUniqueParticipantIds = [];
-    const eventIds = [];
-    const drawIds = [];
-    eventProfiles?.forEach((eventProfile) => {
-        const event = tournamentRecord.events?.find((event, index) => (eventProfile.eventIndex !== undefined && index === eventProfile.eventIndex) ||
-            (eventProfile.eventName && event.eventName === eventProfile.eventName) ||
-            (eventProfile.eventId && event.eventId === eventProfile.eventId));
-        if (event?.gender) {
-            eventProfile.gender = event.gender;
-        }
-    });
-    const participantsCount = tournamentRecord.participants?.length || undefined;
-    if (participantsCount && participantsProfile?.idPrefix) {
-        participantsProfile.idPrefix = `${participantsProfile.idPrefix}-${participantsCount}`;
+function processExistingEvent({ event, eventProfile, tournamentRecord, allUniqueParticipantIds, drawIds }) {
+    const { gender, category, eventType } = event;
+    const { drawProfiles, publish } = eventProfile;
+    const eventParticipantType = (isMatchUpEventType(SINGLES)(eventType) && INDIVIDUAL) ||
+        (isMatchUpEventType(DOUBLES)(eventType) && PAIR) ||
+        eventType;
+    if (drawProfiles) {
+        const { stageParticipantsCount, uniqueParticipantsCount, uniqueParticipantStages } = getStageParticipantsCount({
+            drawProfiles,
+            category,
+            gender,
+        });
+        const { uniqueDrawParticipants = [], uniqueParticipantIds = [] } = uniqueParticipantStages
+            ? generateEventParticipants({
+                event: { eventType, category, gender },
+                uniqueParticipantsCount,
+                participantsProfile: eventProfile.participantsProfile,
+                ratingsParameters: eventProfile.ratingsParameters,
+                tournamentRecord,
+                eventProfile,
+                uuids: eventProfile.uuids,
+            })
+            : {};
+        allUniqueParticipantIds.push(...uniqueParticipantIds);
+        const { stageParticipants } = getStageParticipants({
+            targetParticipants: tournamentRecord.participants || [],
+            allUniqueParticipantIds,
+            stageParticipantsCount,
+            eventParticipantType,
+        });
+        let result = generateFlights({
+            uniqueDrawParticipants,
+            autoEntryPositions: eventProfile.autoEntryPositions,
+            stageParticipants,
+            tournamentRecord,
+            drawProfiles,
+            category,
+            gender,
+            event,
+        });
+        if (result.error)
+            return result;
+        result = generateFlightDrawDefinitions({
+            matchUpStatusProfile: eventProfile.matchUpStatusProfile,
+            completeAllMatchUps: eventProfile.completeAllMatchUps,
+            randomWinningSide: eventProfile.randomWinningSide,
+            tournamentRecord,
+            drawProfiles,
+            isMock: eventProfile.isMock,
+            event,
+        });
+        if (result.error)
+            return result;
+        drawIds.push(...result.drawIds);
     }
-    const result = addTournamentParticipants({
-        startDate: tournamentRecord.startDate,
-        participantsProfile,
-        tournamentRecord,
-        eventProfiles,
-        drawProfiles,
-        uuids,
-    });
-    if (!result.success)
-        return result;
-    if (eventProfiles) {
-        let eventIndex = tournamentRecord.events?.length || 0;
-        for (const eventProfile of eventProfiles) {
-            const { ratingsParameters } = eventProfile;
-            const event = tournamentRecord.events?.find((event, index) => (eventProfile.eventIndex !== undefined && index === eventProfile.eventIndex) ||
-                (eventProfile.eventName && event.eventName === eventProfile.eventName) ||
-                (eventProfile.eventId && event.eventId === eventProfile.eventId));
-            if (!event) {
-                const result = generateEventWithFlights({
-                    startDate: tournamentRecord.startDate,
-                    allUniqueParticipantIds,
-                    matchUpStatusProfile,
-                    participantsProfile,
-                    completeAllMatchUps,
-                    autoEntryPositions,
-                    randomWinningSide,
-                    ratingsParameters,
-                    tournamentRecord,
-                    eventProfile,
-                    eventIndex,
-                    uuids,
-                });
-                if (result.error)
-                    return result;
-                const { eventId, drawIds: generatedDrawIds, uniqueParticipantIds } = result;
-                if (generatedDrawIds)
-                    drawIds.push(...generatedDrawIds);
-                eventIds.push(eventId);
-                if (uniqueParticipantIds?.length)
-                    allUniqueParticipantIds.push(...uniqueParticipantIds);
-                eventIndex += 1;
-            }
-            else {
-                const { gender, category, eventType } = event;
-                const { drawProfiles, publish } = eventProfile;
-                const eventParticipantType = (isMatchUpEventType(SINGLES)(eventType) && INDIVIDUAL) ||
-                    (isMatchUpEventType(DOUBLES)(eventType) && PAIR) ||
-                    eventType;
-                if (drawProfiles) {
-                    const { stageParticipantsCount, uniqueParticipantsCount, uniqueParticipantStages } = getStageParticipantsCount({
-                        drawProfiles,
-                        category,
-                        gender,
-                    });
-                    const { uniqueDrawParticipants = [], uniqueParticipantIds = [] } = uniqueParticipantStages
-                        ? generateEventParticipants({
-                            event: { eventType, category, gender },
-                            uniqueParticipantsCount,
-                            participantsProfile,
-                            ratingsParameters,
-                            tournamentRecord,
-                            eventProfile,
-                            uuids,
-                        })
-                        : {};
-                    allUniqueParticipantIds.push(...uniqueParticipantIds);
-                    const { stageParticipants } = getStageParticipants({
-                        targetParticipants: tournamentRecord.participants || [],
-                        allUniqueParticipantIds,
-                        stageParticipantsCount,
-                        eventParticipantType,
-                    });
-                    let result = generateFlights({
-                        uniqueDrawParticipants,
-                        autoEntryPositions,
-                        stageParticipants,
-                        tournamentRecord,
-                        drawProfiles,
-                        category,
-                        gender,
-                        event,
-                    });
-                    if (result.error)
-                        return result;
-                    result = generateFlightDrawDefinitions({
-                        matchUpStatusProfile,
-                        completeAllMatchUps,
-                        randomWinningSide,
-                        tournamentRecord,
-                        drawProfiles,
-                        isMock,
-                        event,
-                    });
-                    if (result.error)
-                        return result;
-                    drawIds.push(...result.drawIds);
-                }
-                if (publish) {
-                    publishEvent({ tournamentRecord, event });
-                }
-            }
-        }
+    if (publish) {
+        publishEvent({ tournamentRecord, event });
     }
-    if (drawProfiles) {
-        let drawIndex = (tournamentRecord.events || [])
-            .map((event) => event.drawDefinitions?.map(() => 1) || [])
-            .flat()
-            .reduce((a, b) => a + b, 0);
-        for (const drawProfile of drawProfiles) {
-            let result = generateEventWithDraw({
-                startDate: tournamentRecord.startDate,
-                allUniqueParticipantIds,
-                matchUpStatusProfile,
-                participantsProfile,
-                completeAllMatchUps,
-                autoEntryPositions,
-                hydrateCollections,
-                randomWinningSide,
-                ratingsParameters: ratingsParameters$1,
+    return SUCCESS;
+}
+function findEventByProfile(events, eventProfile) {
+    return events?.find((event, index) => (eventProfile.eventIndex !== undefined && index === eventProfile.eventIndex) ||
+        (eventProfile.eventName && event.eventName === eventProfile.eventName) ||
+        (eventProfile.eventId && event.eventId === eventProfile.eventId));
+}
+function processEventProfiles({ eventProfiles, tournamentRecord, allUniqueParticipantIds, eventIds, drawIds, params }) {
+    let eventIndex = tournamentRecord.events?.length || 0;
+    for (const eventProfile of eventProfiles) {
+        const event = findEventByProfile(tournamentRecord.events, eventProfile);
+        if (event) {
+            const result = processExistingEvent({
+                event,
+                eventProfile: { ...eventProfile, ...params },
                 tournamentRecord,
-                drawProfile,
-                drawIndex,
-                uuids,
+                allUniqueParticipantIds,
+                drawIds,
             });
             if (result.error)
                 return result;
-            const { drawId, eventId, event, uniqueParticipantIds } = result;
-            result = addEvent({ tournamentRecord, event, internalUse: true });
+        }
+        else {
+            const result = generateEventWithFlights({
+                startDate: tournamentRecord.startDate,
+                allUniqueParticipantIds,
+                matchUpStatusProfile: params.matchUpStatusProfile,
+                participantsProfile: params.participantsProfile,
+                completeAllMatchUps: params.completeAllMatchUps,
+                autoEntryPositions: params.autoEntryPositions,
+                randomWinningSide: params.randomWinningSide,
+                ratingsParameters: eventProfile.ratingsParameters,
+                tournamentRecord,
+                eventProfile,
+                eventIndex,
+                uuids: params.uuids,
+            });
             if (result.error)
                 return result;
-            if (drawId)
-                drawIds.push(drawId);
+            const { eventId, drawIds: generatedDrawIds, uniqueParticipantIds } = result;
+            if (generatedDrawIds)
+                drawIds.push(...generatedDrawIds);
             eventIds.push(eventId);
             if (uniqueParticipantIds?.length)
                 allUniqueParticipantIds.push(...uniqueParticipantIds);
-            drawIndex += 1;
+            eventIndex += 1;
         }
     }
-    const venueIds = venueProfiles?.length ? generateVenues({ tournamentRecord, venueProfiles }) : [];
+    return SUCCESS;
+}
+function processDrawProfiles({ drawProfiles, tournamentRecord, allUniqueParticipantIds, eventIds, drawIds, params }) {
+    let drawIndex = (tournamentRecord.events || [])
+        .flatMap((event) => event.drawDefinitions?.map(() => 1) || [])
+        .reduce((a, b) => a + b, 0);
+    for (const drawProfile of drawProfiles) {
+        let result = generateEventWithDraw({
+            startDate: tournamentRecord.startDate,
+            allUniqueParticipantIds,
+            matchUpStatusProfile: params.matchUpStatusProfile,
+            participantsProfile: params.participantsProfile,
+            completeAllMatchUps: params.completeAllMatchUps,
+            autoEntryPositions: params.autoEntryPositions,
+            hydrateCollections: params.hydrateCollections,
+            randomWinningSide: params.randomWinningSide,
+            ratingsParameters: params.ratingsParameters,
+            tournamentRecord,
+            drawProfile,
+            drawIndex,
+            uuids: params.uuids,
+        });
+        if (result.error)
+            return result;
+        const { drawId, eventId, event, uniqueParticipantIds } = result;
+        result = addEvent({ tournamentRecord, event, internalUse: true });
+        if (result.error)
+            return result;
+        if (drawId)
+            drawIds.push(drawId);
+        eventIds.push(eventId);
+        if (uniqueParticipantIds?.length)
+            allUniqueParticipantIds.push(...uniqueParticipantIds);
+        drawIndex += 1;
+    }
+    return SUCCESS;
+}
+function applySchedulingProfile({ schedulingProfile, autoSchedule, periodLength, tournamentRecord }) {
     let scheduledRounds;
     let schedulerResult = {};
     if (schedulingProfile?.length) {
@@ -52543,6 +52579,69 @@ function modifyTournamentRecord(params) {
             });
         }
     }
+    return { scheduledRounds, schedulerResult };
+}
+function modifyTournamentRecord(params) {
+    const { participantsProfile = {}, schedulingProfile, tournamentRecord, autoSchedule, eventProfiles, periodLength, venueProfiles, drawProfiles, uuids, } = params;
+    if (!tournamentRecord)
+        return { error: MISSING_TOURNAMENT_RECORD };
+    const allUniqueParticipantIds = [];
+    const eventIds = [];
+    const drawIds = [];
+    eventProfiles?.forEach((eventProfile) => {
+        const event = findEventByProfile(tournamentRecord.events, eventProfile);
+        if (event?.gender) {
+            eventProfile.gender = event.gender;
+        }
+    });
+    const participantsCount = tournamentRecord.participants?.length || undefined;
+    if (participantsCount && participantsProfile?.idPrefix) {
+        participantsProfile.idPrefix = `${participantsProfile.idPrefix}-${participantsCount}`;
+    }
+    const result = addTournamentParticipants({
+        startDate: tournamentRecord.startDate,
+        participantsProfile,
+        tournamentRecord,
+        eventProfiles,
+        drawProfiles,
+        uuids,
+    });
+    if (!result.success)
+        return result;
+    if (eventProfiles) {
+        const eventResult = processEventProfiles({
+            eventProfiles,
+            tournamentRecord,
+            allUniqueParticipantIds,
+            eventIds,
+            drawIds,
+            params,
+        });
+        if (eventResult.error)
+            return eventResult;
+    }
+    if (drawProfiles) {
+        const drawResult = processDrawProfiles({
+            drawProfiles,
+            tournamentRecord,
+            allUniqueParticipantIds,
+            eventIds,
+            drawIds,
+            params,
+        });
+        if (drawResult.error)
+            return drawResult;
+    }
+    const venueIds = venueProfiles?.length ? generateVenues({ tournamentRecord, venueProfiles }) : [];
+    const schedulingResult = applySchedulingProfile({
+        schedulingProfile,
+        autoSchedule,
+        periodLength,
+        tournamentRecord,
+    });
+    if (schedulingResult.error)
+        return schedulingResult;
+    const { scheduledRounds, schedulerResult } = schedulingResult;
     const totalParticipantsCount = tournamentRecord.participants.length;
     return {
         totalParticipantsCount,