tods-competition-factory 2.0.54 → 2.0.56

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.0.54';
+    return '2.0.56';
 }
 
 function isFunction(obj) {
@@ -1823,6 +1823,7 @@ const PARTICIPANT_ID = 'participantId';
 const SCHEDULE_DATES = 'scheduleDates';
 const TOURNAMENT_ID = 'tournamentId';
 const SCHEDULE_DATE = 'scheduleDate';
+const ROUND_NUMBER = 'roundNumber';
 const STRUCTURE_ID = 'structureId';
 const PARTICIPANT = 'participant';
 const MATCHUP_IDS = 'matchUpIds';
@@ -1915,8 +1916,8 @@ function checkRequiredParameters(params, requiredParams, stack) {
     if (!paramError)
         return { valid: true };
     const error = params?.[errorParam] === undefined
-        ? errors[errorParam] || paramError[ERROR] || INVALID_VALUES
-        : (paramError[VALIDATE] && paramError[INVALID]) || INVALID_VALUES;
+        ? errors[errorParam] || paramError[ERROR] || paramError[INVALID] || INVALID_VALUES
+        : (paramError[VALIDATE] && (paramError[ERROR] || paramError[INVALID])) || INVALID_VALUES;
     const param = errorParam ?? (paramError[ONE_OF] && Object.keys(paramError[ONE_OF]).join(', '));
     return decorateResult({
         info: { param, message: paramError[MESSAGE] },
@@ -2098,7 +2099,7 @@ function getIsoDateString(schedule) {
         scheduledDate = extractDate(schedule.scheduledTime);
     if (!scheduledDate)
         return;
-    const extractedTime = extractTime(schedule.scheduledTime);
+    const extractedTime = extractTime$1(schedule.scheduledTime);
     let isoDateString = extractDate(scheduledDate);
     if (isoDateString && extractedTime)
         isoDateString += `T${extractedTime}`;
@@ -2224,8 +2225,8 @@ function isTimeString(timeString) {
     const invalid = parts.length < 2 || !isNumeric || parseInt(parts[0]) > 23 || parseInt(parts[1]) > 60;
     return !invalid;
 }
-function timeStringMinutes(timeString) {
-    const validTimeString = extractTime(timeString);
+function timeStringMinutes$1(timeString) {
+    const validTimeString = extractTime$1(timeString);
     if (!validTimeString)
         return 0;
     const [hours, minutes] = validTimeString.split(':').map((value) => parseInt(value));
@@ -2241,7 +2242,7 @@ function dayMinutesToTimeString(totalMinutes) {
 function tidyTime(timeString) {
     return isTimeString(timeString) ? timeString.split(':').slice(0, 2).map(zeroPad).join(':') : undefined;
 }
-function extractTime(dateString) {
+function extractTime$1(dateString) {
     return isISODateString(dateString) && dateString.indexOf('T') > 0
         ? tidyTime(dateString.split('T').reverse()[0])
         : tidyTime(dateString);
@@ -2302,7 +2303,7 @@ function regularTime(value) {
 }
 function convertTime(value, time24, keepDate) {
     const hasDate = extractDate(value);
-    const timeString = extractTime(value);
+    const timeString = extractTime$1(value);
     const timeValue = hasDate ? timeString : value;
     return !value
         ? undefined
@@ -2354,11 +2355,11 @@ function minutesDifference(date1, date2, absolute = true) {
     return absolute ? Math.abs(Math.round(diff)) : Math.round(diff);
 }
 function addMinutesToTimeString(timeString, minutes) {
-    const validTimeString = extractTime(timeString);
+    const validTimeString = extractTime$1(timeString);
     if (!validTimeString)
         return '00:00';
     const minutesToAdd = isNaN(minutes) ? 0 : minutes;
-    return extractTime(addMinutes(timeToDate(validTimeString), minutesToAdd).toISOString());
+    return extractTime$1(addMinutes(timeToDate(validTimeString), minutesToAdd).toISOString());
 }
 function addMinutes(startDate, minutes) {
     const date = new Date(startDate);
@@ -2381,7 +2382,7 @@ const dateTime = {
     getUTCdateString,
     DateHHMM,
     extractDate,
-    extractTime,
+    extractTime: extractTime$1,
     formatDate,
     getDateByWeek,
     isISODateString,
@@ -2390,7 +2391,7 @@ const dateTime = {
     offsetDate,
     offsetTime,
     sameDay,
-    timeStringMinutes,
+    timeStringMinutes: timeStringMinutes$1,
     timeToDate,
     timeUTC,
     validTimeValue,
@@ -7268,12 +7269,12 @@ function getMatchUpScheduleDetails(params) {
             }));
             if (averageMinutes || recoveryMinutes) {
                 timeAfterRecovery = endTime
-                    ? addMinutesToTimeString(extractTime(endTime), recoveryMinutes)
+                    ? addMinutesToTimeString(extractTime$1(endTime), recoveryMinutes)
                     : addMinutesToTimeString(scheduledTime, averageMinutes + recoveryMinutes);
             }
             if (typeChangeRecoveryMinutes) {
                 typeChangeTimeAfterRecovery = endTime
-                    ? addMinutesToTimeString(extractTime(endTime), typeChangeRecoveryMinutes)
+                    ? addMinutesToTimeString(extractTime$1(endTime), typeChangeRecoveryMinutes)
                     : addMinutesToTimeString(scheduledTime, averageMinutes + typeChangeRecoveryMinutes);
             }
         }
@@ -9458,14 +9459,14 @@ function addUpcomingMatchUps({ drawDefinition, inContextDrawMatchUps }) {
             const timeAfterRecovery = inContextMatchUp.schedule?.timeAfterRecovery;
             if (timeAfterRecovery) {
                 if (winnerTo?.schedule?.scheduledTime) {
-                    const scheduleConflict = timeStringMinutes(winnerTo.schedule.scheduledTime) < timeStringMinutes(timeAfterRecovery);
+                    const scheduleConflict = timeStringMinutes$1(winnerTo.schedule.scheduledTime) < timeStringMinutes$1(timeAfterRecovery);
                     if (scheduleConflict) {
                         scheduleConflictMatchUpIds[winnerTo.matchUpId] = inContextMatchUp.matchUpId;
                         winnerTo.schedule.scheduleConflict = inContextMatchUp.matchUpId;
                     }
                 }
                 if (loserTo?.schedule?.scheduledTime) {
-                    const scheduleConflict = timeStringMinutes(loserTo.schedule.scheduledTime) < timeStringMinutes(timeAfterRecovery);
+                    const scheduleConflict = timeStringMinutes$1(loserTo.schedule.scheduledTime) < timeStringMinutes$1(timeAfterRecovery);
                     if (scheduleConflict) {
                         scheduleConflictMatchUpIds[loserTo.matchUpId] = inContextMatchUp.matchUpId;
                         loserTo.schedule.scheduleConflict = inContextMatchUp.matchUpId;
@@ -11517,7 +11518,7 @@ function addScheduleItem(params) {
         participantMap[participantId].scheduleItems.push({
             ...schedule,
             scheduledDate: extractDate(schedule?.scheduledDate),
-            scheduledTime: extractTime(schedule?.scheduledTime),
+            scheduledTime: extractTime$1(schedule?.scheduledTime),
             checkScoreHasValue: checkScoreHasValue({ score }),
             matchUpStatus,
             roundPosition,
@@ -12314,7 +12315,7 @@ function getParticipantEntries(params) {
                 for (const scheduleItem of scheduleItems) {
                     const { typeChangeTimeAfterRecovery, timeAfterRecovery, scheduledDate, scheduledTime } = scheduleItem;
                     const scheduleItemsToConsider = dateItems[scheduledDate];
-                    const scheduledMinutes = timeStringMinutes(scheduledTime);
+                    const scheduledMinutes = timeStringMinutes$1(scheduledTime);
                     for (const consideredItem of scheduleItemsToConsider) {
                         const ignoreItem = consideredItem.matchUpId === scheduleItem.matchUpId ||
                             ([WALKOVER$2, DEFAULTED].includes(consideredItem.matchUpStatus) && !consideredItem.checkScoreHasValue);
@@ -12324,12 +12325,12 @@ function getParticipantEntries(params) {
                         const notBeforeTime = typeChange ? typeChangeTimeAfterRecovery || timeAfterRecovery : timeAfterRecovery;
                         const sameDraw = scheduleItem.drawId === consideredItem.drawId;
                         const bothPotential = potentialMatchUps[scheduleItem.matchUpId] && potentialMatchUps[consideredItem.matchUpId];
-                        const consideredMinutes = timeStringMinutes(consideredItem.scheduledTime);
+                        const consideredMinutes = timeStringMinutes$1(consideredItem.scheduledTime);
                         const minutesDifference = Math.abs(consideredMinutes - scheduledMinutes);
                         const itemIsPrior = consideredMinutes >= scheduledMinutes;
                         const timeOverlap = scheduledMinutesDifference && !isNaN(scheduledMinutesDifference)
                             ? minutesDifference <= scheduledMinutesDifference
-                            : itemIsPrior && timeStringMinutes(consideredItem.scheduledTime) < timeStringMinutes(notBeforeTime);
+                            : itemIsPrior && timeStringMinutes$1(consideredItem.scheduledTime) < timeStringMinutes$1(notBeforeTime);
                         if (timeOverlap && !(bothPotential && sameDraw) && itemIsPrior) {
                             const key = [scheduleItem.matchUpId, consideredItem.matchUpId].sort(stringSort).join('|');
                             participantAggregator.scheduleConflicts[key] = {
@@ -13200,9 +13201,10 @@ function addEventEntries(params) {
             entries: event.entries || [],
         });
     }
-    const addedEntriesCount = addedParticipantIdEntries.length - removedEntries.length;
+    const addedEntriesCount = addedParticipantIdEntries.length;
+    const removedEntriesCount = removedEntries.length;
     return decorateResult({
-        result: { ...SUCCESS, addedEntriesCount },
+        result: { ...SUCCESS, addedEntriesCount, removedEntriesCount },
         stack,
         info,
     });
@@ -15561,250 +15563,6 @@ function qualifierDrawPositionAssignment(params) {
     return qualifierDrawPositionAssignment$1(params);
 }
 
-function swapDrawPositionAssignments$1({ tournamentRecord, drawDefinition, drawPositions, structureId, event }) {
-    if (!drawDefinition)
-        return { error: MISSING_DRAW_DEFINITION };
-    if (!structureId)
-        return { error: MISSING_STRUCTURE_ID };
-    if (drawPositions?.length !== 2)
-        return { error: INVALID_VALUES, drawPositions };
-    const matchUpsMap = getMatchUpsMap({ drawDefinition });
-    const { matchUps: inContextDrawMatchUps } = getAllDrawMatchUps({
-        inContext: true,
-        drawDefinition,
-        matchUpsMap,
-    });
-    const { structure } = findStructure({ drawDefinition, structureId });
-    if (!structure)
-        return { error: STRUCTURE_NOT_FOUND };
-    const appliedPolicies = getAppliedPolicies({
-        tournamentRecord,
-        drawDefinition,
-        event,
-    }).appliedPolicies ?? {};
-    let result;
-    if (structure.structureType === CONTAINER) {
-        result = roundRobinSwap({
-            inContextDrawMatchUps,
-            tournamentRecord,
-            drawDefinition,
-            drawPositions,
-            matchUpsMap,
-            structure,
-            event,
-        });
-    }
-    else {
-        result = eliminationSwap({
-            inContextDrawMatchUps,
-            tournamentRecord,
-            drawDefinition,
-            drawPositions,
-            matchUpsMap,
-            structure,
-            event,
-        });
-    }
-    if (result.error)
-        return result;
-    conditionallyDisableLinkPositioning({ structure, drawPositions });
-    const positionAction = {
-        name: 'swapDrawPositionAssignments',
-        drawPositions,
-        structureId,
-    };
-    addPositionActionTelemetry({ appliedPolicies, drawDefinition, positionAction });
-    modifyPositionAssignmentsNotice({
-        tournamentId: tournamentRecord?.tournamentId,
-        drawDefinition,
-        structure,
-        event,
-    });
-    if (event.eventType === TEAM_EVENT) {
-        const inContextTargetMatchUps = getAllStructureMatchUps({
-            matchUpFilters: { matchUpTypes: [TEAM_MATCHUP] },
-            inContext: true,
-            structure,
-        }).matchUps.filter((matchUp) => matchUp.drawPositions?.some((drawPosition) => drawPositions.includes(drawPosition)));
-        const structureMatchUps = getAllStructureMatchUps({
-            matchUpFilters: { matchUpTypes: [TEAM_MATCHUP] },
-            structure,
-        }).matchUps;
-        inContextTargetMatchUps.forEach((inContextTargetMatchUp) => {
-            (inContextTargetMatchUp.sides || []).forEach((inContextSide) => {
-                const drawPosition = inContextSide?.drawPosition;
-                if (drawPositions.includes(drawPosition)) {
-                    const teamParticipantId = inContextSide.participantId;
-                    const matchUp = structureMatchUps.find(({ matchUpId }) => matchUpId === inContextTargetMatchUp.matchUpId);
-                    const drawPositionSideIndex = inContextTargetMatchUp?.sides?.reduce((index, side, i) => (side.drawPosition === drawPosition ? i : index), undefined);
-                    updateSideLineUp({
-                        inContextTargetMatchUp,
-                        drawPositionSideIndex,
-                        teamParticipantId,
-                        tournamentRecord,
-                        drawDefinition,
-                        matchUp,
-                        event,
-                    });
-                }
-            });
-        });
-    }
-    modifyDrawNotice({ drawDefinition, structureIds: [structureId] });
-    return { ...SUCCESS };
-}
-function eliminationSwap({ inContextDrawMatchUps, tournamentRecord, drawDefinition, drawPositions, matchUpsMap, structure, event, }) {
-    const assignments = structure?.positionAssignments.filter((assignment) => drawPositions?.includes(assignment.drawPosition));
-    if (!assignments) {
-        return {
-            error: INVALID_VALUES,
-            structure,
-            info: 'Missing positionAssignments',
-        };
-    }
-    if (assignments.filter(({ bye }) => bye).length === 2)
-        return { ...SUCCESS };
-    if (assignments.filter(({ qualifier }) => qualifier).length === 2)
-        return { ...SUCCESS };
-    const isQualifierSwap = assignments.some(({ qualifier }) => qualifier);
-    const isByeSwap = assignments.some(({ bye }) => bye);
-    if (isByeSwap && !isQualifierSwap) {
-        return swapParticipantIdWithBYE({
-            inContextDrawMatchUps,
-            tournamentRecord,
-            drawDefinition,
-            assignments,
-            matchUpsMap,
-            structure,
-            event,
-        });
-    }
-    else {
-        return eliminationPosiitonSwap({
-            inContextDrawMatchUps,
-            tournamentRecord,
-            drawDefinition,
-            assignments,
-            matchUpsMap,
-            structure,
-            event,
-        });
-    }
-}
-function swapParticipantIdWithBYE({ inContextDrawMatchUps, tournamentRecord, drawDefinition, assignments, matchUpsMap, structure, event, }) {
-    const originalByeAssignment = assignments.find(({ bye }) => bye);
-    const originalParticipantIdAssignment = assignments.find(({ participantId }) => participantId);
-    const originalByeDrawPosition = originalByeAssignment.drawPosition;
-    const { participantId, drawPosition: originalParticipantIdDrawPosition } = originalParticipantIdAssignment;
-    const { structureId } = structure;
-    let result = removeDrawPositionAssignment({
-        drawPosition: originalByeDrawPosition,
-        inContextDrawMatchUps,
-        tournamentRecord,
-        drawDefinition,
-        structureId,
-        matchUpsMap,
-    });
-    if (result.error)
-        return result;
-    result = removeDrawPositionAssignment({
-        drawPosition: originalParticipantIdDrawPosition,
-        inContextDrawMatchUps,
-        tournamentRecord,
-        drawDefinition,
-        structureId,
-        matchUpsMap,
-    });
-    if (result.error)
-        return result;
-    assignDrawPositionBye({
-        drawPosition: originalParticipantIdDrawPosition,
-        tournamentRecord,
-        drawDefinition,
-        structureId,
-        matchUpsMap,
-        event,
-    });
-    result = assignDrawPosition$1({
-        drawPosition: originalByeDrawPosition,
-        inContextDrawMatchUps,
-        tournamentRecord,
-        drawDefinition,
-        structureId,
-        participantId,
-        matchUpsMap,
-        event,
-    });
-    if (result.error)
-        return result;
-    return { ...SUCCESS };
-}
-function eliminationPosiitonSwap({ inContextDrawMatchUps, tournamentRecord, drawDefinition, assignments, matchUpsMap, structure, event, }) {
-    const newAssignments = Object.assign({}, ...assignments.map((assignment, index) => {
-        const { drawPosition } = assignment;
-        const newAssignment = { ...assignments[1 - index], drawPosition };
-        return { [drawPosition]: newAssignment };
-    }));
-    structure.positionAssignments = structure.positionAssignments.map((assignment) => newAssignments[assignment.drawPosition] || assignment);
-    resetLineUps({
-        inContextDrawMatchUps,
-        tournamentRecord,
-        drawDefinition,
-        matchUpsMap,
-        assignments,
-        structure,
-        event,
-    });
-    return { ...SUCCESS };
-}
-function roundRobinSwap({ inContextDrawMatchUps, tournamentRecord, drawDefinition, drawPositions, matchUpsMap, structure, event, }) {
-    const assignments = structure.structures?.reduce((assignments, structure) => {
-        const structureAssignments = structure?.positionAssignments.filter((assignment) => drawPositions?.includes(assignment.drawPosition));
-        if (structureAssignments)
-            assignments.push(...structureAssignments);
-        return assignments;
-    }, []);
-    if (assignments.filter(({ bye }) => bye).length === 2)
-        return { ...SUCCESS };
-    if (assignments.filter(({ qualifier }) => qualifier).length === 2)
-        return { ...SUCCESS };
-    resetLineUps({
-        inContextDrawMatchUps,
-        tournamentRecord,
-        drawDefinition,
-        matchUpsMap,
-        assignments,
-        structure,
-        event,
-    });
-    const isQualifierSwap = assignments.some(({ qualifier }) => qualifier);
-    const isByeSwap = assignments.some(({ bye }) => bye);
-    if (isByeSwap && !isQualifierSwap) {
-        swapParticipantIdWithBYE({
-            inContextDrawMatchUps,
-            tournamentRecord,
-            drawDefinition,
-            assignments,
-            matchUpsMap,
-            structure,
-            event,
-        });
-    }
-    else {
-        const originalAssignments = makeDeepCopy(assignments, false, true);
-        assignments.forEach((assignment, index) => {
-            const newParticipantId = originalAssignments[1 - index].participantId;
-            assignment.qualifier = originalAssignments[1 - index].qualifier;
-            assignment.participantId = newParticipantId;
-        });
-    }
-    return { ...SUCCESS };
-}
-
-function swapDrawPositionAssignments(params) {
-    return swapDrawPositionAssignments$1(params);
-}
-
 function modifySeedAssignment({ validation = true, tournamentRecord, drawDefinition, participantId, structureId, seedValue, event, }) {
     if (!drawDefinition)
         return { error: MISSING_DRAW_DEFINITION };
@@ -17893,8 +17651,14 @@ function renameStructures({ drawDefinition, structureDetails }) {
     }
     for (const structure of drawDefinition.structures || []) {
         const structureName = detailMap[structure.structureId];
-        if (structureName) {
+        if (structureName)
             structure.structureName = structureName;
+        if (structure.structures) {
+            for (const subStructure of structure.structures) {
+                const subStructureName = detailMap[subStructure.structureId];
+                if (subStructureName)
+                    subStructure.structureName = subStructureName;
+            }
         }
     }
     return { ...SUCCESS };
@@ -18156,6 +17920,289 @@ function addVoluntaryConsolationStage(params) {
     return addVoluntaryConsolationStage$1(params);
 }
 
+const QUALIFYING_PARTICIPANT_METHOD = 'qualifierDrawPositionAssignment';
+const WITHDRAW_PARTICIPANT_METHOD = 'withdrawParticipantAtDrawPosition';
+const ALTERNATE_PARTICIPANT_METHOD = 'alternateDrawPositionAssignment';
+const LUCKY_PARTICIPANT_METHOD = 'luckyLoserDrawPositionAssignment';
+const REMOVE_ASSIGNMENT_METHOD = 'removeDrawPositionAssignment';
+const SWAP_PARTICIPANT_METHOD = 'swapDrawPositionAssignments';
+const MODIFY_PAIR_ASSIGNMENT_METHOD = 'modifyPairAssignment';
+const SWAP_ADHOC_PARTICIPANT_METHOD = 'adHocPositionSwap';
+const ADD_NICKNAME_METHOD = 'modifyParticipantOtherName';
+const ASSIGN_PARTICIPANT_METHOD = 'assignDrawPosition';
+const REMOVE_SEED_METHOD = 'removeSeededParticipant';
+const ASSIGN_BYE_METHOD = 'assignDrawPositionBye';
+const SEED_VALUE_METHOD = 'modifySeedAssignment';
+const ADD_PENALTY_METHOD = 'addPenalty';
+const MODIFY_PAIR_ASSIGNMENT = 'MODIFY_PAIR';
+const QUALIFYING_PARTICIPANT = 'QUALIFIER';
+const ALTERNATE_PARTICIPANT = 'ALTERNATE';
+const WITHDRAW_PARTICIPANT = 'WITHDRAW';
+const ASSIGN_PARTICIPANT = 'ASSIGN';
+const REMOVE_ASSIGNMENT = 'REMOVE';
+const LUCKY_PARTICIPANT = 'LUCKY';
+const REMOVE_SEED = 'REMOVE_SEED';
+const SWAP_PARTICIPANTS = 'SWAP';
+const ADD_NICKNAME = 'NICKNAME';
+const SEED_VALUE = 'SEED_VALUE';
+const ADD_PENALTY = 'PENALTY';
+const ASSIGN_BYE = 'BYE';
+const positionActionConstants = {
+    MODIFY_PAIR_ASSIGNMENT,
+    QUALIFYING_PARTICIPANT,
+    ALTERNATE_PARTICIPANT,
+    WITHDRAW_PARTICIPANT,
+    ASSIGN_PARTICIPANT,
+    LUCKY_PARTICIPANT,
+    REMOVE_ASSIGNMENT,
+    SWAP_PARTICIPANTS,
+    ADD_NICKNAME,
+    REMOVE_SEED,
+    ADD_PENALTY,
+    ASSIGN_BYE,
+    SEED_VALUE,
+};
+
+function swapDrawPositionAssignments({ tournamentRecord, drawDefinition, drawPositions, structureId, event }) {
+    if (!drawDefinition)
+        return { error: MISSING_DRAW_DEFINITION };
+    if (!structureId)
+        return { error: MISSING_STRUCTURE_ID };
+    if (drawPositions?.length !== 2)
+        return { error: INVALID_VALUES, drawPositions };
+    const matchUpsMap = getMatchUpsMap({ drawDefinition });
+    const { matchUps: inContextDrawMatchUps } = getAllDrawMatchUps({
+        inContext: true,
+        drawDefinition,
+        matchUpsMap,
+    });
+    const { structure } = findStructure({ drawDefinition, structureId });
+    if (!structure)
+        return { error: STRUCTURE_NOT_FOUND };
+    const appliedPolicies = getAppliedPolicies({
+        tournamentRecord,
+        drawDefinition,
+        event,
+    }).appliedPolicies ?? {};
+    let result;
+    if (structure.structureType === CONTAINER) {
+        result = roundRobinSwap({
+            inContextDrawMatchUps,
+            tournamentRecord,
+            drawDefinition,
+            drawPositions,
+            matchUpsMap,
+            structure,
+            event,
+        });
+    }
+    else {
+        result = eliminationSwap({
+            inContextDrawMatchUps,
+            tournamentRecord,
+            drawDefinition,
+            drawPositions,
+            matchUpsMap,
+            structure,
+            event,
+        });
+    }
+    if (result.error)
+        return result;
+    conditionallyDisableLinkPositioning({ structure, drawPositions });
+    const positionAction = {
+        name: SWAP_PARTICIPANT_METHOD,
+        drawPositions,
+        structureId,
+    };
+    addPositionActionTelemetry({ appliedPolicies, drawDefinition, positionAction });
+    modifyPositionAssignmentsNotice({
+        tournamentId: tournamentRecord?.tournamentId,
+        drawDefinition,
+        structure,
+        event,
+    });
+    if (event.eventType === TEAM_EVENT) {
+        const inContextTargetMatchUps = getAllStructureMatchUps({
+            matchUpFilters: { matchUpTypes: [TEAM_MATCHUP] },
+            inContext: true,
+            structure,
+        }).matchUps.filter((matchUp) => matchUp.drawPositions?.some((drawPosition) => drawPositions.includes(drawPosition)));
+        const structureMatchUps = getAllStructureMatchUps({
+            matchUpFilters: { matchUpTypes: [TEAM_MATCHUP] },
+            structure,
+        }).matchUps;
+        inContextTargetMatchUps.forEach((inContextTargetMatchUp) => {
+            (inContextTargetMatchUp.sides || []).forEach((inContextSide) => {
+                const drawPosition = inContextSide?.drawPosition;
+                if (drawPositions.includes(drawPosition)) {
+                    const teamParticipantId = inContextSide.participantId;
+                    const matchUp = structureMatchUps.find(({ matchUpId }) => matchUpId === inContextTargetMatchUp.matchUpId);
+                    const drawPositionSideIndex = inContextTargetMatchUp?.sides?.reduce((index, side, i) => (side.drawPosition === drawPosition ? i : index), undefined);
+                    updateSideLineUp({
+                        inContextTargetMatchUp,
+                        drawPositionSideIndex,
+                        teamParticipantId,
+                        tournamentRecord,
+                        drawDefinition,
+                        matchUp,
+                        event,
+                    });
+                }
+            });
+        });
+    }
+    modifyDrawNotice({ drawDefinition, structureIds: [structureId] });
+    return { ...SUCCESS };
+}
+function eliminationSwap({ inContextDrawMatchUps, tournamentRecord, drawDefinition, drawPositions, matchUpsMap, structure, event, }) {
+    const assignments = structure?.positionAssignments.filter((assignment) => drawPositions?.includes(assignment.drawPosition));
+    if (!assignments) {
+        return {
+            error: INVALID_VALUES,
+            structure,
+            info: 'Missing positionAssignments',
+        };
+    }
+    if (assignments.filter(({ bye }) => bye).length === 2)
+        return { ...SUCCESS };
+    if (assignments.filter(({ qualifier }) => qualifier).length === 2)
+        return { ...SUCCESS };
+    const isQualifierSwap = assignments.some(({ qualifier }) => qualifier);
+    const isByeSwap = assignments.some(({ bye }) => bye);
+    if (isByeSwap && !isQualifierSwap) {
+        return swapParticipantIdWithBYE({
+            inContextDrawMatchUps,
+            tournamentRecord,
+            drawDefinition,
+            assignments,
+            matchUpsMap,
+            structure,
+            event,
+        });
+    }
+    else {
+        return eliminationPosiitonSwap({
+            inContextDrawMatchUps,
+            tournamentRecord,
+            drawDefinition,
+            assignments,
+            matchUpsMap,
+            structure,
+            event,
+        });
+    }
+}
+function swapParticipantIdWithBYE({ inContextDrawMatchUps, tournamentRecord, drawDefinition, assignments, matchUpsMap, structure, event, }) {
+    const originalByeAssignment = assignments.find(({ bye }) => bye);
+    const originalParticipantIdAssignment = assignments.find(({ participantId }) => participantId);
+    const originalByeDrawPosition = originalByeAssignment.drawPosition;
+    const { participantId, drawPosition: originalParticipantIdDrawPosition } = originalParticipantIdAssignment;
+    const { structureId } = structure;
+    let result = removeDrawPositionAssignment({
+        drawPosition: originalByeDrawPosition,
+        inContextDrawMatchUps,
+        tournamentRecord,
+        drawDefinition,
+        structureId,
+        matchUpsMap,
+    });
+    if (result.error)
+        return result;
+    result = removeDrawPositionAssignment({
+        drawPosition: originalParticipantIdDrawPosition,
+        inContextDrawMatchUps,
+        tournamentRecord,
+        drawDefinition,
+        structureId,
+        matchUpsMap,
+    });
+    if (result.error)
+        return result;
+    assignDrawPositionBye({
+        drawPosition: originalParticipantIdDrawPosition,
+        tournamentRecord,
+        drawDefinition,
+        structureId,
+        matchUpsMap,
+        event,
+    });
+    result = assignDrawPosition$1({
+        drawPosition: originalByeDrawPosition,
+        inContextDrawMatchUps,
+        tournamentRecord,
+        drawDefinition,
+        structureId,
+        participantId,
+        matchUpsMap,
+        event,
+    });
+    if (result.error)
+        return result;
+    return { ...SUCCESS };
+}
+function eliminationPosiitonSwap({ inContextDrawMatchUps, tournamentRecord, drawDefinition, assignments, matchUpsMap, structure, event, }) {
+    const newAssignments = Object.assign({}, ...assignments.map((assignment, index) => {
+        const { drawPosition } = assignment;
+        const newAssignment = { ...assignments[1 - index], drawPosition };
+        return { [drawPosition]: newAssignment };
+    }));
+    structure.positionAssignments = structure.positionAssignments.map((assignment) => newAssignments[assignment.drawPosition] || assignment);
+    resetLineUps({
+        inContextDrawMatchUps,
+        tournamentRecord,
+        drawDefinition,
+        matchUpsMap,
+        assignments,
+        structure,
+        event,
+    });
+    return { ...SUCCESS };
+}
+function roundRobinSwap({ inContextDrawMatchUps, tournamentRecord, drawDefinition, drawPositions, matchUpsMap, structure, event, }) {
+    const assignments = structure.structures?.reduce((assignments, structure) => {
+        const structureAssignments = structure?.positionAssignments.filter((assignment) => drawPositions?.includes(assignment.drawPosition));
+        if (structureAssignments)
+            assignments.push(...structureAssignments);
+        return assignments;
+    }, []);
+    if (assignments.filter(({ bye }) => bye).length === 2)
+        return { ...SUCCESS };
+    if (assignments.filter(({ qualifier }) => qualifier).length === 2)
+        return { ...SUCCESS };
+    resetLineUps({
+        inContextDrawMatchUps,
+        tournamentRecord,
+        drawDefinition,
+        matchUpsMap,
+        assignments,
+        structure,
+        event,
+    });
+    const isQualifierSwap = assignments.some(({ qualifier }) => qualifier);
+    const isByeSwap = assignments.some(({ bye }) => bye);
+    if (isByeSwap && !isQualifierSwap) {
+        swapParticipantIdWithBYE({
+            inContextDrawMatchUps,
+            tournamentRecord,
+            drawDefinition,
+            assignments,
+            matchUpsMap,
+            structure,
+            event,
+        });
+    }
+    else {
+        const originalAssignments = makeDeepCopy(assignments, false, true);
+        assignments.forEach((assignment, index) => {
+            const newParticipantId = originalAssignments[1 - index].participantId;
+            assignment.qualifier = originalAssignments[1 - index].qualifier;
+            assignment.participantId = newParticipantId;
+        });
+    }
+    return { ...SUCCESS };
+}
+
 function removeSeededParticipant({ tournamentRecord, drawDefinition, participantId, structureId, }) {
     const stack = 'removeSeededParticipant';
     if (!tournamentRecord)
@@ -18476,6 +18523,50 @@ function addQualifying(params) {
     });
 }
 
+function adHocPositionSwap(params) {
+    const paramsCheck = checkRequiredParameters(params, [
+        { [DRAW_DEFINITION]: true, [STRUCTURE_ID]: true, [MATCHUP_ID]: true },
+        { [ROUND_NUMBER]: true, [VALIDATE]: (value) => Number.isInteger(value) && value > 0 },
+        {
+            [VALIDATE]: (value) => Array.isArray(value) && value.length === 2 && value.every(isString),
+            [INVALID]: INVALID_PARTICIPANT_IDS,
+            participantIds: true,
+        },
+    ]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const { drawDefinition, structureId, tournamentRecord, event } = params;
+    const { structure } = findStructure({ drawDefinition, structureId });
+    if (!structure)
+        return { error: STRUCTURE_NOT_FOUND };
+    if (!isAdHoc({ structure }))
+        return { error: INVALID_STRUCTURE };
+    const hasParticipant = (matchUp) => matchUp.sides?.map((side) => side.participantId).some((id) => params.participantIds.includes(id));
+    const targetRoundNumber = (matchUp) => matchUp.roundNumber === params.roundNumber;
+    const noScoreValue = (matchUp) => !checkScoreHasValue(matchUp);
+    const targetMatchUps = (structure?.matchUps ?? [])
+        .filter(targetRoundNumber)
+        .filter(noScoreValue)
+        .filter(hasParticipant);
+    if (targetMatchUps.length !== 2)
+        return { error: INVALID_PARTICIPANT_IDS };
+    for (const matchUp of targetMatchUps) {
+        const side = matchUp?.sides?.find((side) => params.participantIds.includes(side?.participantId));
+        if (side) {
+            const swappedParticipantId = params.participantIds.find((id) => id !== side?.participantId);
+            side.participantId = swappedParticipantId;
+            modifyMatchUpNotice({
+                tournamentId: tournamentRecord?.tournamentId,
+                eventId: event?.eventId,
+                drawDefinition,
+                matchUp,
+            });
+        }
+    }
+    modifyDrawNotice({ drawDefinition, structureIds: [structureId] });
+    return { ...SUCCESS };
+}
+
 function buildFeedRound({ includeMatchUpType, drawPosition, roundNumber, matchUpType, idPrefix, matchUps, isMock, uuids, nodes, fed, }) {
     const feedRoundMatchUpsCount = nodes.length;
     const initialGroupDrawPosition = drawPosition ? drawPosition - feedRoundMatchUpsCount : undefined;
@@ -20067,8 +20158,8 @@ function calculatePercentages({ participantResults, matchUpFormat, tallyPolicy,
         let gamesPct = Math.round((gamesWon / gamesTotal) * 1000) / 1000;
         if (gamesPct === Infinity || isNaN(gamesPct))
             gamesPct = 0;
-        let pointsPct = Math.round((participantResults[participantId].pointsWon / participantResults[participantId].pointsLost) * 1000) /
-            1000;
+        const pointsTotal = participantResults[participantId].pointsWon + participantResults[participantId].pointsLost;
+        let pointsPct = Math.round((participantResults[participantId].pointsWon / pointsTotal) * 1000) / 1000;
         if (pointsPct === Infinity || isNaN(pointsPct))
             pointsPct = 0;
         participantResults[participantId].setsWon = setsWon;
@@ -23630,6 +23721,7 @@ function setSubOrder({ tournamentRecord, drawDefinition, drawPosition, structure
 
 var mutate$c = {
     __proto__: null,
+    adHocPositionSwap: adHocPositionSwap,
     addAdHocMatchUps: addAdHocMatchUps,
     addDrawDefinitionTimeItem: addDrawDefinitionTimeItem,
     addPlayoffStructures: addPlayoffStructures,
@@ -23961,48 +24053,6 @@ function getSourceStructureIdsAndRelevantLinks({ targetRoundNumber, finishingPos
     return { sourceStructureIds, relevantLinks };
 }
 
-const QUALIFYING_PARTICIPANT_METHOD = 'qualifierDrawPositionAssignment';
-const WITHDRAW_PARTICIPANT_METHOD = 'withdrawParticipantAtDrawPosition';
-const ALTERNATE_PARTICIPANT_METHOD = 'alternateDrawPositionAssignment';
-const LUCKY_PARTICIPANT_METHOD = 'luckyLoserDrawPositionAssignment';
-const REMOVE_ASSIGNMENT_METHOD = 'removeDrawPositionAssignment';
-const SWAP_PARTICIPANT_METHOD = 'swapDrawPositionAssignments';
-const MODIFY_PAIR_ASSIGNMENT_METHOD = 'modifyPairAssignment';
-const ADD_NICKNAME_METHOD = 'modifyParticipantOtherName';
-const ASSIGN_PARTICIPANT_METHOD = 'assignDrawPosition';
-const REMOVE_SEED_METHOD = 'removeSeededParticipant';
-const ASSIGN_BYE_METHOD = 'assignDrawPositionBye';
-const SEED_VALUE_METHOD = 'modifySeedAssignment';
-const ADD_PENALTY_METHOD = 'addPenalty';
-const MODIFY_PAIR_ASSIGNMENT = 'MODIFY_PAIR';
-const QUALIFYING_PARTICIPANT = 'QUALIFIER';
-const ALTERNATE_PARTICIPANT = 'ALTERNATE';
-const WITHDRAW_PARTICIPANT = 'WITHDRAW';
-const ASSIGN_PARTICIPANT = 'ASSIGN';
-const REMOVE_ASSIGNMENT = 'REMOVE';
-const LUCKY_PARTICIPANT = 'LUCKY';
-const REMOVE_SEED = 'REMOVE_SEED';
-const SWAP_PARTICIPANTS = 'SWAP';
-const ADD_NICKNAME = 'NICKNAME';
-const SEED_VALUE = 'SEED_VALUE';
-const ADD_PENALTY = 'PENALTY';
-const ASSIGN_BYE = 'BYE';
-const positionActionConstants = {
-    MODIFY_PAIR_ASSIGNMENT,
-    QUALIFYING_PARTICIPANT,
-    ALTERNATE_PARTICIPANT,
-    WITHDRAW_PARTICIPANT,
-    ASSIGN_PARTICIPANT,
-    LUCKY_PARTICIPANT,
-    REMOVE_ASSIGNMENT,
-    SWAP_PARTICIPANTS,
-    ADD_NICKNAME,
-    REMOVE_SEED,
-    ADD_PENALTY,
-    ASSIGN_BYE,
-    SEED_VALUE,
-};
-
 function getValidModifyAssignedPairAction({ tournamentParticipants, returnParticipants, drawPosition, participant, drawId, event, }) {
     const availableIndividualParticipantIds = event?.entries
         ?.filter(({ entryStatus }) => [UNGROUPED, UNPAIRED].includes(entryStatus))
@@ -24422,7 +24472,10 @@ function getEventAlternateParticipantIds({ eventEntries, structure }) {
 
 function adHocMatchUpActions({ restrictAdHocRoundParticipants, tournamentParticipants, matchUpParticipantIds, otherFlightEntries, drawDefinition, structureId, sideNumber, matchUpId, structure, matchUp, drawId, event, }) {
     const validActions = [];
-    const roundMatchUps = (structure?.matchUps ?? []).filter(({ roundNumber }) => roundNumber === matchUp.roundNumber);
+    const matchUps = structure?.matchUps ?? [];
+    const side = matchUp.sides?.find((side) => side.sideNumber === sideNumber);
+    const sideParticipantId = side?.participantId;
+    const roundMatchUps = matchUps.filter(({ roundNumber }) => roundNumber === matchUp.roundNumber);
     const enteredParticipantIds = drawDefinition?.entries
         ?.filter(({ entryStatus }) => entryStatus && DIRECT_ENTRY_STATUSES.includes(entryStatus))
         .map(getParticipantId) ?? [];
@@ -24483,13 +24536,46 @@ function adHocMatchUpActions({ restrictAdHocRoundParticipants, tournamentPartici
             type: ALTERNATE,
         });
     }
-    if (!checkScoreHasValue(matchUp) && sideNumber) {
-        const side = matchUp.sides?.find((side) => side.sideNumber === sideNumber);
-        if (side?.participantId) {
+    if (!checkScoreHasValue(matchUp) && sideNumber && sideParticipantId) {
+        validActions.push({
+            payload: { drawId, matchUpId, structureId, sideNumber },
+            method: REMOVE_SIDE_METHOD,
+            type: REMOVE_PARTICIPANT,
+        });
+        const getMatchUpPairing = (matchUp) => matchUp.sides.map(getParticipantId);
+        const notThisMatchUp = ({ matchUpId }) => matchUpId !== matchUp.matchUpId;
+        const noScoreValue = (matchUp) => !checkScoreHasValue(matchUp);
+        const opponentParticipantId = matchUp.sides?.find((side) => side.sideNumber !== sideNumber)?.participantId;
+        const otherRoundMatchUps = matchUps.filter(({ roundNumber }) => roundNumber !== matchUp.roundNumber);
+        const otherRoundParticipantPairings = otherRoundMatchUps.filter(notThisMatchUp).map(getMatchUpPairing);
+        const otherOpponents = [
+            opponentParticipantId,
+            ...otherRoundParticipantPairings.filter((pairing) => pairing.includes(sideParticipantId)).flat(),
+        ].filter(Boolean);
+        const notPreviousOpponent = (id) => !otherOpponents.flat().includes(id);
+        const availableSwaps = roundMatchUps
+            .filter(noScoreValue)
+            .filter(notThisMatchUp)
+            .map(getMatchUpPairing)
+            .flat()
+            .filter(notPreviousOpponent);
+        if (availableSwaps.length) {
+            const swappableParticipants = tournamentParticipants
+                ?.filter((participant) => availableSwaps.includes(participant.participantId))
+                .map((participant) => makeDeepCopy(participant, undefined, true));
             validActions.push({
-                payload: { drawId, matchUpId, structureId, sideNumber },
-                method: REMOVE_SIDE_METHOD,
-                type: REMOVE_PARTICIPANT,
+                payload: {
+                    participantIds: [sideParticipantId],
+                    roundNumber: matchUp.roundNumber,
+                    structureId,
+                    sideNumber,
+                    matchUpId,
+                    drawId,
+                },
+                swappableParticipantIds: availableSwaps,
+                method: SWAP_ADHOC_PARTICIPANT_METHOD,
+                type: SWAP_PARTICIPANTS,
+                swappableParticipants,
             });
         }
     }
@@ -25595,6 +25681,7 @@ var query$b = {
     getAvailablePlayoffProfiles: getAvailablePlayoffProfiles,
     getDrawDefinitionTimeItem: getDrawDefinitionTimeItem,
     getDrawParticipantRepresentativeIds: getDrawParticipantRepresentativeIds,
+    getDrawStructures: getDrawStructures,
     getDrawTypeCoercion: getDrawTypeCoercion,
     getEligibleVoluntaryConsolationParticipants: getEligibleVoluntaryConsolationParticipants,
     getMatchUpsMap: getMatchUpsMap,
@@ -34182,6 +34269,13 @@ function getDrawIsPublished({ publishStatus, drawId }) {
     return true;
 }
 
+const PUBLIC_DISPLAY = 'PUBLIC';
+const ADMIN_DISPLAY = 'ADMIN';
+const displayConstants = {
+    PUBLIC_DISPLAY,
+    ADMIN_DISPLAY,
+};
+
 function getDrawData(params) {
     const { tournamentParticipants = [], includePositionAssignments, policyDefinitions, tournamentRecord, inContext = true, usePublishState, status = PUBLIC, pressureRating, refreshResults, drawDefinition, noDeepCopy, sortConfig, context, event, } = params;
     if (!drawDefinition)
@@ -34289,7 +34383,8 @@ function getDrawData(params) {
                     stage,
                 }))(structure)
                 : {};
-            structureInfo.display = findExtension({ element: structure, name: DISPLAY }).extension?.value;
+            const displaySettings = findExtension({ element: structure, name: DISPLAY }).extension?.value;
+            structureInfo.display = displaySettings?.[PUBLIC_DISPLAY] ?? displaySettings;
             structureInfo.sourceStructureIds = sourceStructureIds[structureId];
             structureInfo.hasDrawFeedProfile = hasDrawFeedProfile[structureId];
             structureInfo.positionAssignments = positionAssignments;
@@ -35561,7 +35656,7 @@ function participantScheduledMatchUps({ scheduleAttributes = ['scheduledDate', '
         .reduce((dateMatchUps, matchUp) => {
         const { schedule } = matchUp;
         const date = extractDate(schedule?.scheduledDate);
-        const time = extractTime(schedule?.scheduledTime);
+        const time = extractTime$1(schedule?.scheduledTime);
         if (date && time) {
             if (dateMatchUps[date]) {
                 dateMatchUps[date].push(matchUp);
@@ -35574,7 +35669,7 @@ function participantScheduledMatchUps({ scheduleAttributes = ['scheduledDate', '
     }, {});
     const dates = Object.keys(scheduledMatchUps);
     dates.forEach((date) => {
-        scheduledMatchUps[date].sort((a, b) => timeSort(extractTime(a.schedule?.scheduledTime), extractTime(b.schedule?.scheduledTime)));
+        scheduledMatchUps[date].sort((a, b) => timeSort(extractTime$1(a.schedule?.scheduledTime), extractTime$1(b.schedule?.scheduledTime)));
     });
     return { ...SUCCESS, scheduledMatchUps };
 }
@@ -35630,7 +35725,7 @@ function scheduledSortedMatchUps({ schedulingProfile, matchUps = [] }) {
         const timeGroups = { noScheduledTime: [] };
         for (const matchUp of dateGroup) {
             const schedule = matchUp.schedule || {};
-            const scheduledTime = (schedule.scheduledTime && extractTime(schedule.scheduledTime)) || 'noScheduledTime';
+            const scheduledTime = (schedule.scheduledTime && extractTime$1(schedule.scheduledTime)) || 'noScheduledTime';
             if (!timeGroups[scheduledTime])
                 timeGroups[scheduledTime] = [];
             timeGroups[scheduledTime].push(matchUp);
@@ -37167,6 +37262,7 @@ var index$f = {
     getDrawData: getDrawData,
     getDrawDefinitionTimeItem: getDrawDefinitionTimeItem,
     getDrawParticipantRepresentativeIds: getDrawParticipantRepresentativeIds,
+    getDrawStructures: getDrawStructures,
     getDrawTypeCoercion: getDrawTypeCoercion,
     getEligibleVoluntaryConsolationParticipants: getEligibleVoluntaryConsolationParticipants,
     getEntriesAndSeedsCount: getEntriesAndSeedsCount,
@@ -37504,6 +37600,7 @@ function autoSeeding({ tournamentRecord, drawDefinition, policyDefinitions, scal
 
 var index$e = {
     __proto__: null,
+    adHocPositionSwap: adHocPositionSwap,
     addAdHocMatchUps: addAdHocMatchUps,
     addDrawDefinitionTimeItem: addDrawDefinitionTimeItem,
     addFinishingRounds: addFinishingRounds,
@@ -37541,6 +37638,7 @@ var index$e = {
     getAvailablePlayoffProfiles: getAvailablePlayoffProfiles,
     getDrawDefinitionTimeItem: getDrawDefinitionTimeItem,
     getDrawParticipantRepresentativeIds: getDrawParticipantRepresentativeIds,
+    getDrawStructures: getDrawStructures,
     getDrawTypeCoercion: getDrawTypeCoercion,
     getEligibleVoluntaryConsolationParticipants: getEligibleVoluntaryConsolationParticipants,
     getMatchUpsMap: getMatchUpsMap,
@@ -37983,11 +38081,11 @@ function addParticipants({ allowDuplicateParticipantIdPairs, returnParticipants,
     }
 }
 
-function addEventEntryPairs({ allowDuplicateParticipantIdPairs, entryStage = MAIN, entryStatus = ALTERNATE, participantIdPairs = [], tournamentRecord, drawDefinition, event, uuids, }) {
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    if (!event)
-        return { error: MISSING_EVENT };
+function addEventEntryPairs(params) {
+    const paramsCheck = checkRequiredParameters(params, [{ [TOURNAMENT_RECORD]: true, [EVENT]: true }]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const { allowDuplicateParticipantIdPairs, entryStatus = ALTERNATE, participantIdPairs = [], entryStage = MAIN, tournamentRecord, drawDefinition, event, uuids, } = params;
     if (event.eventType !== DOUBLES)
         return { error: INVALID_EVENT_TYPE };
     const existingParticipantIdPairs = [];
@@ -38004,10 +38102,10 @@ function addEventEntryPairs({ allowDuplicateParticipantIdPairs, entryStage = MAI
     const invalidParticipantIdPairs = participantIdPairs.filter((pair) => {
         if (pair.length !== 2)
             return true;
-        if (!genderMap.has(pair[0]) || !genderMap.has(pair[1]))
-            return true;
         if (!event.gender || event.gender === ANY)
             return false;
+        if (!genderMap.has(pair[0]) || !genderMap.has(pair[1]))
+            return true;
         const participantGenders = pair.map((id) => genderMap.get(id));
         let invalidParticiapntGenders = (event.gender === MALE && (participantGenders[0] !== MALE || participantGenders[1] !== MALE)) ||
             (event.gender === FEMALE && (participantGenders[0] !== FEMALE || participantGenders[1] !== FEMALE));
@@ -40028,7 +40126,7 @@ function generateTimeSlots(params) {
         .sort((a, b) => tidyTime(a.startTime).localeCompare(tidyTime(b.startTime)))
         .forEach((booking) => {
         const timeSlot = {
-            startTime: extractTime(startTime.toISOString()),
+            startTime: extractTime$1(startTime.toISOString()),
             endTime: booking.startTime,
         };
         if (timeToDate(booking.startTime) > startTime) {
@@ -40039,7 +40137,7 @@ function generateTimeSlots(params) {
         }
     });
     const timeSlot = {
-        startTime: extractTime(startTime.toISOString()),
+        startTime: extractTime$1(startTime.toISOString()),
         endTime: courtDate.endTime,
     };
     if (timeToDate(courtDate.endTime) > startTime) {
@@ -40157,7 +40255,7 @@ function generateVirtualCourts(params) {
             },
         };
     });
-    unassignedBookings.sort((a, b) => timeStringMinutes(a.startTime) - timeStringMinutes(b.startTime));
+    unassignedBookings.sort((a, b) => timeStringMinutes$1(a.startTime) - timeStringMinutes$1(b.startTime));
     const getCourtTimeSlots = () => inProcessCourts
         .map((court) => {
         const courtDate = court.dateAvailability;
@@ -40172,15 +40270,15 @@ function generateVirtualCourts(params) {
     const assignedBookings = [];
     for (const unassignedBooking of unassignedBookings) {
         const { startTime, endTime, averageMinutes, recoveryMinutes, matchUpId } = unassignedBooking;
-        const startMinutes = timeStringMinutes(startTime);
-        const endMinutes = timeStringMinutes(endTime);
+        const startMinutes = timeStringMinutes$1(startTime);
+        const endMinutes = timeStringMinutes$1(endTime);
         const courtTimeSlots = getCourtTimeSlots();
         const bestCourt = courtTimeSlots.reduce((best, { courtId, courtName, timeSlots }) => {
             let startDifference;
             const timeSlot = timeSlots.find(({ startTime, endTime }) => {
-                startDifference = timeStringMinutes(startTime) - startMinutes;
-                const startFits = startMinutes >= timeStringMinutes(startTime);
-                const endFits = endMinutes <= timeStringMinutes(endTime);
+                startDifference = timeStringMinutes$1(startTime) - startMinutes;
+                const startFits = startMinutes >= timeStringMinutes$1(startTime);
+                const endFits = endMinutes <= timeStringMinutes$1(endTime);
                 return (endFits &&
                     best.startDifference !== 0 &&
                     (((startDifference === 0 || startDifference + periodLength >= 0) &&
@@ -40235,8 +40333,8 @@ function getDateTimeBoundary({ scheduleDate, startTime, endTime, courts }) {
         const comparisonTime = accessor && (dateAvailability?.[accessor] || court[accessor]);
         return comparisonTime &&
             (!boundaryTime ||
-                (startTime && timeStringMinutes(comparisonTime) < timeStringMinutes(boundaryTime)) ||
-                (endTime && timeStringMinutes(comparisonTime) > timeStringMinutes(boundaryTime)))
+                (startTime && timeStringMinutes$1(comparisonTime) < timeStringMinutes$1(boundaryTime)) ||
+                (endTime && timeStringMinutes$1(comparisonTime) > timeStringMinutes$1(boundaryTime)))
             ? comparisonTime
             : boundaryTime;
     }, undefined);
@@ -40264,7 +40362,7 @@ function getFirstTimeSlotStartTime({ averageMinutes, startTime, endTime, courts,
                 const timeSlotMinutes = minutesDifference(timeSlotStartTime, timeSlotEndTime);
                 const available = timeSlotMinutes >= averageMinutes;
                 if (available) {
-                    const timeString = extractTime(timeSlotStartTime.toISOString());
+                    const timeString = extractTime$1(timeSlotStartTime.toISOString());
                     if (!firstTimeSlotStartTime || timeString < firstTimeSlotStartTime) {
                         firstTimeSlotStartTime = timeString;
                     }
@@ -40284,8 +40382,8 @@ function getScheduleTimes(params) {
     const { calculateStartTimeFromCourts = true, remainingScheduleTimes, averageMatchUpMinutes, clearScheduleDates, courtsCount, bookings, } = params;
     periodLength = periodLength || calculatePeriodLength({ averageMatchUpMinutes });
     date = extractDate(date);
-    startTime = extractTime(startTime);
-    endTime = extractTime(endTime);
+    startTime = extractTime$1(startTime);
+    endTime = extractTime$1(endTime);
     let previousCalculation = 0;
     let previousAvailableCourts = 0;
     let cumulativeMatches = 0;
@@ -40312,8 +40410,8 @@ function getScheduleTimes(params) {
     if (calculateStartTimeFromCourts && firstTimeSlotStartTime) {
         startTime = firstTimeSlotStartTime ? firstTimeSlotStartTime : startTime;
     }
-    const dayStartMinutes = timeStringMinutes(startTime);
-    const dayEndMinutes = timeStringMinutes(endTime);
+    const dayStartMinutes = timeStringMinutes$1(startTime);
+    const dayEndMinutes = timeStringMinutes$1(endTime);
     const dayMinutes = dayEndMinutes - dayStartMinutes;
     const periodCount = Math.floor(dayMinutes / periodLength);
     const periods = generateRange(0, periodCount + 1);
@@ -43144,7 +43242,7 @@ function assignMatchUpCourt({ removePriorValues, tournamentRecords, tournamentRe
 }
 
 function timeDate(value, scheduledDate) {
-    const time = validTimeString.test(value) ? value : extractTime(value);
+    const time = validTimeString.test(value) ? value : extractTime$1(value);
     const date = extractDate(value) || extractDate(scheduledDate) || formatDate(new Date());
     return new Date(`${date}T${time}`).getTime();
 }
@@ -45154,13 +45252,13 @@ function addParticipantPotentialRecovery({ individualParticipantProfiles, recove
 }
 
 function updateTimeAfterRecovery({ matchUpPotentialParticipantIds, individualParticipantProfiles, typeChangeRecoveryMinutes, averageMatchUpMinutes = 0, matchUpNotBeforeTimes, matchUpDependencies, recoveryMinutes = 0, scheduleTime, matchUp, }) {
-    const endTime = extractTime(matchUp?.schedule?.endTime);
+    const endTime = extractTime$1(matchUp?.schedule?.endTime);
     const timeAfterRecovery = endTime
         ? addMinutesToTimeString(endTime, ensureInt(recoveryMinutes))
         : addMinutesToTimeString(scheduleTime, ensureInt(averageMatchUpMinutes) + ensureInt(recoveryMinutes));
     const typeChangeTimeAfterRecovery = typeChangeRecoveryMinutes &&
         (endTime
-            ? addMinutesToTimeString(extractTime(endTime), typeChangeRecoveryMinutes)
+            ? addMinutesToTimeString(extractTime$1(endTime), typeChangeRecoveryMinutes)
             : addMinutesToTimeString(scheduleTime, ensureInt(averageMatchUpMinutes) + ensureInt(typeChangeRecoveryMinutes)));
     const participantIdDependencies = matchUpDependencies?.[matchUp.matchUpId]?.participantIds || [];
     const potentialIndividualParticipantIds = ((matchUp.roundPosition && matchUpPotentialParticipantIds[matchUp.matchUpId]) ||
@@ -45215,12 +45313,12 @@ function checkDependendantTiming({ matchUpScheduleTimes, matchUpDependencies, sc
             };
             if (candidateScheduleTime && !dependent.matchUpId)
                 return candidateDependent;
-            return timeStringMinutes(candidateScheduleTime) < timeStringMinutes(dependent.scheduleTime)
+            return timeStringMinutes$1(candidateScheduleTime) < timeStringMinutes$1(dependent.scheduleTime)
                 ? candidateDependent
                 : dependent;
         }, {});
         if (earliestDependent.scheduleTime &&
-            timeStringMinutes(dependentNotBeforeTime) > timeStringMinutes(earliestDependent.scheduleTime)) {
+            timeStringMinutes$1(dependentNotBeforeTime) > timeStringMinutes$1(earliestDependent.scheduleTime)) {
             scheduledDependent = earliestDependent;
         }
     }
@@ -45256,8 +45354,8 @@ function checkRequestConflicts({ averageMatchUpMinutes = 90, requestConflicts =
         .filter((request) => request.requestType === DO_NOT_SCHEDULE && sameDay(scheduleDate, request.date));
     const conflicts = [];
     const matchUpId = matchUp?.matchUpId;
-    const scheduleStart = timeToDate(extractTime(scheduleTime), extractDate(scheduleDate));
-    const averageEnd = extractTime(addMinutes(scheduleStart, averageMatchUpMinutes).toISOString());
+    const scheduleStart = timeToDate(extractTime$1(scheduleTime), extractDate(scheduleDate));
+    const averageEnd = extractTime$1(addMinutes(scheduleStart, averageMatchUpMinutes).toISOString());
     for (const request of relevantPersonRequests) {
         const { requestId, startTime, endTime } = request;
         const conflict = (scheduleTime > startTime && scheduleTime < endTime) || (averageEnd > startTime && averageEnd < endTime);
@@ -45450,7 +45548,7 @@ function generateBookings({ defaultRecoveryMinutes = 0, averageMatchUpMinutes =
             eventType,
         });
         const { courtId, venueId } = schedule;
-        const startTime = extractTime(schedule.scheduledTime);
+        const startTime = extractTime$1(schedule.scheduledTime);
         const endTime = addMinutesToTimeString(startTime, averageMinutes);
         return {
             recoveryMinutes,
@@ -45645,10 +45743,10 @@ function getVenueSchedulingDetails({ matchUpPotentialParticipantIds, individualP
 }
 
 function analyzeScheduleOverlap(a, b) {
-    const startA = timeStringMinutes(a.scheduleTime);
-    const endA = timeStringMinutes(a.timeAfterRecovery);
-    const startB = timeStringMinutes(b.scheduleTime);
-    const endB = timeStringMinutes(b.timeAfterRecovery);
+    const startA = timeStringMinutes$1(a.scheduleTime);
+    const endA = timeStringMinutes$1(a.timeAfterRecovery);
+    const startB = timeStringMinutes$1(b.scheduleTime);
+    const endB = timeStringMinutes$1(b.timeAfterRecovery);
     const startOrEndEquivalence = startA === startB || endA === endB;
     const startAisContained = startA > startB && startA < endB;
     const startBisContained = startB > startA && startB < endA;
@@ -45676,7 +45774,7 @@ function checkRecoveryTime({ individualParticipantProfiles, matchUpNotBeforeTime
         const profile = individualParticipantProfiles[participantId];
         if (!profile.timeAfterRecovery)
             return true;
-        const endTime = extractTime(matchUp?.schedule?.endTime);
+        const endTime = extractTime$1(matchUp?.schedule?.endTime);
         const timeAfterRecovery = endTime
             ? addMinutesToTimeString(endTime, ensureInt(recoveryMinutes))
             : addMinutesToTimeString(scheduleTime, ensureInt(averageMatchUpMinutes) + ensureInt(recoveryMinutes));
@@ -46109,7 +46207,7 @@ function jinnScheduler({ schedulingProfileModifications, checkPotentialRequestCo
                 }
             });
             noTimeMatchUpIds[scheduleDate] = venueScheduledRoundDetails[venueId].matchUpsToSchedule.map(getMatchUpId);
-            scheduleTimesRemaining[scheduleDate][venueId] = venueScheduledRoundDetails[venueId].scheduleTimes.sort((a, b) => timeStringMinutes(a.scheduleTime) - timeStringMinutes(b.scheduleTime));
+            scheduleTimesRemaining[scheduleDate][venueId] = venueScheduledRoundDetails[venueId].scheduleTimes.sort((a, b) => timeStringMinutes$1(a.scheduleTime) - timeStringMinutes$1(b.scheduleTime));
         }
         if (!dryRun && allDateScheduledByeMatchUpDetails?.length) {
             bulkScheduleMatchUps({
@@ -46199,7 +46297,7 @@ function getEarliestCourtTime({ averageMinutes, startTime, endTime, court, date
         const timeSlotMinutes = minutesDifference(consideredStartTime, timeSlotEndTime);
         const available = timeSlotMinutes >= averageMinutes;
         if (available) {
-            const timeString = extractTime(consideredStartTime.toISOString());
+            const timeString = extractTime$1(consideredStartTime.toISOString());
             if (!first || timeString < first)
                 first = timeString;
         }
@@ -46352,7 +46450,7 @@ function v2Scheduler({ schedulingProfileModifications, checkPotentialRequestConf
                                 court,
                             });
                             if (courtTime.scheduleTime &&
-                                timeStringMinutes(scheduleTime) >= timeStringMinutes(courtTime.scheduleTime)) {
+                                timeStringMinutes$1(scheduleTime) >= timeStringMinutes$1(courtTime.scheduleTime)) {
                                 return courtTime;
                             }
                             const { scheduledDependent } = checkDependendantTiming({
@@ -46407,7 +46505,7 @@ function v2Scheduler({ schedulingProfileModifications, checkPotentialRequestConf
                                 matchUp,
                             });
                             if (!courtTime.scheduleTime ||
-                                timeStringMinutes(scheduleTime) < timeStringMinutes(courtTime.scheduleTime)) {
+                                timeStringMinutes$1(scheduleTime) < timeStringMinutes$1(courtTime.scheduleTime)) {
                                 courtTime.averageMatchUpMinutes = averageMatchUpMinutes;
                                 courtTime.recoveryMinutes = recoveryMinutes;
                                 courtTime.scheduleTime = scheduleTime;
@@ -49604,11 +49702,11 @@ function addCourt({ tournamentRecord, disableNotice, venueId, courtId, court })
         const dateAvailability = (court?.dateAvailability || []).map((availabilty) => ({
             ...availabilty,
             date: extractDate(availabilty.date),
-            startTime: extractTime(availabilty.startTime),
-            endTime: extractTime(availabilty.endTime),
+            startTime: extractTime$1(availabilty.startTime),
+            endTime: extractTime$1(availabilty.endTime),
             bookings: availabilty.bookings?.map(({ startTime, endTime, bookingType }) => ({
-                startTime: extractTime(startTime),
-                endTime: extractTime(endTime),
+                startTime: extractTime$1(startTime),
+                endTime: extractTime$1(endTime),
                 bookingType,
             })),
         }));
@@ -50544,8 +50642,8 @@ function mergePersonRequests({ personRequests, personId, requests }) {
         let { date, startTime, endTime } = request;
         if (request.requestType === DO_NOT_SCHEDULE) {
             date = extractDate(date);
-            startTime = extractTime(startTime);
-            endTime = extractTime(endTime);
+            startTime = extractTime$1(startTime);
+            endTime = extractTime$1(endTime);
             if (date && startTime && endTime) {
                 return { date, startTime, endTime, requestType: request.requestType };
             }
@@ -52528,7 +52626,7 @@ function getVenueReport(dates, venue, matchUps) {
             const timeSlots = courtDate && generateTimeSlots({ courtDate }).timeSlots;
             const courtAvailableMinutes = timeSlots?.reduce((minutes, timeSlot) => {
                 const { startTime, endTime } = timeSlot;
-                const timeSlotMinutes = timeStringMinutes(endTime) - timeStringMinutes(startTime);
+                const timeSlotMinutes = timeStringMinutes$1(endTime) - timeStringMinutes$1(startTime);
                 return minutes + timeSlotMinutes;
             }, 0);
             if (courtAvailableMinutes)
@@ -52537,9 +52635,9 @@ function getVenueReport(dates, venue, matchUps) {
         }
         const venueMatchUps = matchUps.filter(({ schedule }) => schedule.venueId === venueId && sameDay(date, schedule.scheduledDate));
         venueMatchUps.forEach(({ schedule }) => {
-            const startTime = extractTime(schedule.scheduledTime);
+            const startTime = extractTime$1(schedule.scheduledTime);
             const endTime = addMinutesToTimeString(startTime, schedule.averageMinutes);
-            const matchUpScheduledMinutes = timeStringMinutes(endTime) - timeStringMinutes(startTime);
+            const matchUpScheduledMinutes = timeStringMinutes$1(endTime) - timeStringMinutes$1(startTime);
             scheduledMinutes += matchUpScheduledMinutes;
         });
         const percentUtilization = availableMinutes ? ((scheduledMinutes / availableMinutes) * 100).toFixed(2) : '100';
@@ -52586,7 +52684,7 @@ function calculateScheduleTimes({ calculateStartTimeFromCourts = true, defaultRe
             const dateAvailability = court.dateAvailability?.find((availability) => !availability.date || sameDay(scheduleDate, availability.date));
             const comparisonStartTime = dateAvailability?.startTime ?? court.startTime;
             return comparisonStartTime &&
-                (!minStartTime || timeStringMinutes(comparisonStartTime) < timeStringMinutes(minStartTime))
+                (!minStartTime || timeStringMinutes$1(comparisonStartTime) < timeStringMinutes$1(minStartTime))
                 ? comparisonStartTime
                 : minStartTime;
         }, undefined);
@@ -52595,7 +52693,7 @@ function calculateScheduleTimes({ calculateStartTimeFromCourts = true, defaultRe
         endTime = courts?.reduce((maxEndTime, court) => {
             const dateAvailability = court.dateAvailability?.find((availability) => !availability.date || sameDay(scheduleDate, availability.date));
             const comparisonEndTime = dateAvailability?.endTime ?? court.endTime;
-            return comparisonEndTime && (!maxEndTime || timeStringMinutes(comparisonEndTime) > timeStringMinutes(maxEndTime))
+            return comparisonEndTime && (!maxEndTime || timeStringMinutes$1(comparisonEndTime) > timeStringMinutes$1(maxEndTime))
                 ? comparisonEndTime
                 : maxEndTime;
         }, undefined);
@@ -52640,7 +52738,7 @@ function calculateScheduleTimes({ calculateStartTimeFromCourts = true, defaultRe
             timingDetails,
         });
         const { courtId, venueId } = schedule;
-        const startTime = extractTime(schedule.scheduledTime);
+        const startTime = extractTime$1(schedule.scheduledTime);
         const endTime = addMinutesToTimeString(startTime, averageMinutes);
         return {
             recoveryMinutes,
@@ -52928,8 +53026,8 @@ function scheduleMatchUps(params) {
     const { venueId, scheduleTimes, dateScheduledMatchUpIds } = calculateScheduleTimes({
         tournamentRecords,
         remainingScheduleTimes,
-        startTime: extractTime(startTime),
-        endTime: extractTime(endTime),
+        startTime: extractTime$1(startTime),
+        endTime: extractTime$1(endTime),
         scheduleDate: extractDate(scheduleDate),
         averageMatchUpMinutes,
         clearScheduleDates,
@@ -53447,7 +53545,7 @@ function bulkReschedule({ tournamentRecord, scheduleChange, matchUpIds, dryRun }
                 }
                 if (minutesChange && scheduledTime) {
                     const scheduledTimeDate = extractDate(scheduledTime);
-                    const currentDayMinutes = timeStringMinutes(extractTime(scheduledTime));
+                    const currentDayMinutes = timeStringMinutes$1(extractTime$1(scheduledTime));
                     const newTime = currentDayMinutes + minutesChange;
                     doNotReschedule = newTime < 0 || newTime > dayTotalMinutes;
                     if (!doNotReschedule) {
@@ -55647,11 +55745,11 @@ function updateCourtAvailability({ tournamentRecord }) {
     }
     for (const court of courts) {
         const { startTime, endTime } = (court.dateAvailability ?? []).reduce((extents, availability) => {
-            const startMinutes = timeStringMinutes(extents.startTime);
-            const endMinutes = timeStringMinutes(extents.endTime);
-            if (availability.startTime && timeStringMinutes(availability.startTime) < startMinutes)
+            const startMinutes = timeStringMinutes$1(extents.startTime);
+            const endMinutes = timeStringMinutes$1(extents.endTime);
+            if (availability.startTime && timeStringMinutes$1(availability.startTime) < startMinutes)
                 extents.startTime = availability.startTime;
-            if (availability.endTime && timeStringMinutes(availability.endTime) > endMinutes)
+            if (availability.endTime && timeStringMinutes$1(availability.endTime) > endMinutes)
                 extents.endTime = availability.endTime;
             return extents;
         }, { startTime: '08:00', endTime: '18:00' });
@@ -56593,7 +56691,7 @@ function visualizeScheduledMatchUps({ scheduledMatchUps, showGlobalLog }) {
                 },
             }, true);
             roundMatchUps[roundNumber].forEach(({ matchUpId, schedule }) => {
-                const scheduledTime = extractTime(schedule.scheduledTime);
+                const scheduledTime = extractTime$1(schedule.scheduledTime);
                 pushGlobalLog({
                     matchUpId,
                     time: scheduledTime,
@@ -56613,6 +56711,31 @@ function visualizeScheduledMatchUps({ scheduledMatchUps, showGlobalLog }) {
         printGlobalLog();
 }
 
+const { extractTime, timeStringMinutes } = dateTime;
+function matchUpScheduleSort(a, b) {
+    const scheduleA = a.schedule ?? {};
+    const scheduleB = b.schedule ?? {};
+    if (scheduleA.scheduledDate && !scheduleB.scheduledDate)
+        return 1;
+    if (scheduleB.scheduledDate && !scheduleA.scheduledDate)
+        return -1;
+    if (scheduleA.scheduledDate && scheduleB.scheduledDate) {
+        if (scheduleA.scheduledDate === scheduleB.scheduledDate) {
+            if (scheduleA.scheduledTime && !scheduleB.scheduledTime)
+                return 1;
+            if (scheduleB.scheduledTime && !scheduleA.scheduledTime)
+                return -1;
+            if (scheduleA.scheduledTime && scheduleB.scheduledTime) {
+                const timeA = timeStringMinutes(extractTime(scheduleA.scheduledTime));
+                const timeB = timeStringMinutes(extractTime(scheduleB.scheduledTime));
+                return timeA - timeB;
+            }
+        }
+        return new Date(scheduleA.scheduledDate).getTime() - new Date(scheduleB.scheduledDate).getTime();
+    }
+    return 0;
+}
+
 function dehydrateMatchUps({ tournamentRecord }) {
     if (!tournamentRecord)
         return { error: MISSING_TOURNAMENT_RECORD };
@@ -56833,6 +56956,7 @@ var index$1 = {
     isOdd: isOdd,
     isPowerOf2: isPowerOf2,
     makeDeepCopy: makeDeepCopy,
+    matchUpScheduleSort: matchUpScheduleSort,
     matchUpSort: matchUpSort,
     nearestPowerOf2: nearestPowerOf2,
     nextPowerOf2: nextPowerOf2,
@@ -58453,6 +58577,7 @@ var index = {
     auditConstants: auditConstants,
     completedMatchUpStatuses: completedMatchUpStatuses,
     directingMatchUpStatuses: directingMatchUpStatuses,
+    displayConstants: displayConstants,
     drawDefinitionConstants: drawDefinitionConstants,
     entryStatusConstants: entryStatusConstants,
     errorConditionConstants: errorConditionConstants,
@@ -58498,6 +58623,7 @@ exports.competitionEngine = competitionEngine;
 exports.competitionGovernor = index$h;
 exports.completedMatchUpStatuses = completedMatchUpStatuses;
 exports.directingMatchUpStatuses = directingMatchUpStatuses;
+exports.displayConstants = displayConstants;
 exports.drawDefinitionConstants = drawDefinitionConstants;
 exports.drawsGovernor = index$e;
 exports.entriesGovernor = index$d;