tods-competition-factory 2.0.55 → 2.0.57

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.0.55';
+    return '2.0.57';
 }
 
 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] },
@@ -15562,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 };
@@ -17894,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 };
@@ -18157,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)
@@ -18477,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;
@@ -20068,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;
@@ -23631,6 +23721,7 @@ function setSubOrder({ tournamentRecord, drawDefinition, drawPosition, structure
 
 var mutate$c = {
     __proto__: null,
+    adHocPositionSwap: adHocPositionSwap,
     addAdHocMatchUps: addAdHocMatchUps,
     addDrawDefinitionTimeItem: addDrawDefinitionTimeItem,
     addPlayoffStructures: addPlayoffStructures,
@@ -23962,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))
@@ -24423,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) ?? [];
@@ -24484,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,
             });
         }
     }
@@ -25596,6 +25681,7 @@ var query$b = {
     getAvailablePlayoffProfiles: getAvailablePlayoffProfiles,
     getDrawDefinitionTimeItem: getDrawDefinitionTimeItem,
     getDrawParticipantRepresentativeIds: getDrawParticipantRepresentativeIds,
+    getDrawStructures: getDrawStructures,
     getDrawTypeCoercion: getDrawTypeCoercion,
     getEligibleVoluntaryConsolationParticipants: getEligibleVoluntaryConsolationParticipants,
     getMatchUpsMap: getMatchUpsMap,
@@ -27396,7 +27482,7 @@ function reverseScore(params) {
     };
 }
 
-var generate$2 = {
+var generate$3 = {
     __proto__: null,
     generateScoreString: generateScoreString,
     generateTieMatchUpScore: generateTieMatchUpScore,
@@ -30861,7 +30947,7 @@ var scoreGovernor = {
     checkScoreHasValue: checkScoreHasValue,
     checkSetIsComplete: checkSetIsComplete,
     clearHistory: clearHistory,
-    generate: generate$2,
+    generate: generate$3,
     generateScoreString: generateScoreString,
     generateTieMatchUpScore: generateTieMatchUpScore,
     getSetComplement: getSetComplement,
@@ -37176,6 +37262,7 @@ var index$f = {
     getDrawData: getDrawData,
     getDrawDefinitionTimeItem: getDrawDefinitionTimeItem,
     getDrawParticipantRepresentativeIds: getDrawParticipantRepresentativeIds,
+    getDrawStructures: getDrawStructures,
     getDrawTypeCoercion: getDrawTypeCoercion,
     getEligibleVoluntaryConsolationParticipants: getEligibleVoluntaryConsolationParticipants,
     getEntriesAndSeedsCount: getEntriesAndSeedsCount,
@@ -37513,6 +37600,7 @@ function autoSeeding({ tournamentRecord, drawDefinition, policyDefinitions, scal
 
 var index$e = {
     __proto__: null,
+    adHocPositionSwap: adHocPositionSwap,
     addAdHocMatchUps: addAdHocMatchUps,
     addDrawDefinitionTimeItem: addDrawDefinitionTimeItem,
     addFinishingRounds: addFinishingRounds,
@@ -37550,6 +37638,7 @@ var index$e = {
     getAvailablePlayoffProfiles: getAvailablePlayoffProfiles,
     getDrawDefinitionTimeItem: getDrawDefinitionTimeItem,
     getDrawParticipantRepresentativeIds: getDrawParticipantRepresentativeIds,
+    getDrawStructures: getDrawStructures,
     getDrawTypeCoercion: getDrawTypeCoercion,
     getEligibleVoluntaryConsolationParticipants: getEligibleVoluntaryConsolationParticipants,
     getMatchUpsMap: getMatchUpsMap,
@@ -46750,7 +46839,7 @@ function scheduleProfileRounds(params) {
     }
 }
 
-function newTournamentRecord(params) {
+function createTournamentRecord(params) {
     const attributes = params || {};
     if (!attributes.tournamentId)
         attributes.tournamentId = UUID();
@@ -48589,7 +48678,7 @@ function smartComplete(params) {
     });
 }
 
-function generateFlightDrawDefinitions({ matchUpStatusProfile, completeAllMatchUps, randomWinningSide, tournamentRecord, drawProfiles, event, }) {
+function generateFlightDrawDefinitions({ matchUpStatusProfile, completeAllMatchUps, randomWinningSide, tournamentRecord, drawProfiles, isMock, event, }) {
     const flightProfile = getFlightProfile({ event }).flightProfile;
     const { eventName, eventType, category } = event;
     const { startDate } = tournamentRecord;
@@ -48630,10 +48719,10 @@ function generateFlightDrawDefinitions({ matchUpStatusProfile, completeAllMatchU
                     matchUpType: eventType,
                     seedingScaleName,
                     tournamentRecord,
-                    isMock: true,
                     drawEntries,
                     drawName,
                     drawId,
+                    isMock,
                     event,
                     stage,
                 });
@@ -48663,8 +48752,8 @@ function generateFlightDrawDefinitions({ matchUpStatusProfile, completeAllMatchU
                         ...drawProfile.withPlayoffs,
                         tournamentRecord,
                         drawDefinition,
-                        isMock: true,
                         structureId,
+                        isMock,
                         event,
                     });
                     if (result?.error)
@@ -48928,6 +49017,7 @@ function generateEventWithFlights(params) {
             randomWinningSide,
             tournamentRecord,
             drawProfiles,
+            isMock,
             event,
         });
         if (drawDefinitionResult.error)
@@ -49885,6 +49975,7 @@ const mockTournamentNames = [
 function generateTournamentRecord(params) {
     let { startDate, endDate } = params ?? {};
     const { tournamentName = randomPop(mockTournamentNames), ratingsParameters: ratingsParameters$1 = ratingsParameters, tournamentExtensions, policyDefinitions, schedulingProfile, venueProfiles, uuids, } = params ?? {};
+    const isMock = params?.isMock === false ? undefined : true;
     if ((startDate && !isValidDateString(startDate)) || (endDate && !isValidDateString(endDate)))
         return { error: INVALID_DATE };
     if ((params.leagueProfiles && !Array.isArray(params.leagueProfiles)) ||
@@ -49900,18 +49991,18 @@ function generateTournamentRecord(params) {
         const tournamentDate = new Date(startDate);
         endDate = formatDate(tournamentDate.setDate(tournamentDate.getDate() + 7));
     }
-    const tournamentRecord = newTournamentRecord({
+    const tournamentRecord = createTournamentRecord({
         ...(params.tournamentAttributes ?? {}),
         tournamentName,
-        isMock: true,
         startDate,
         endDate,
+        isMock,
     });
     const venueIds = venueProfiles?.length ? generateVenues({ tournamentRecord, venueProfiles, uuids }) : [];
     if (tournamentExtensions?.length && Array.isArray(tournamentExtensions)) {
         const extensions = tournamentExtensions.filter((extension) => isValidExtension({ extension }));
         if (extensions?.length)
-            Object.assign(tournamentRecord, { extensions, isMock: true });
+            Object.assign(tournamentRecord, { extensions, isMock });
     }
     if (typeof policyDefinitions === 'object') {
         for (const policyType of Object.keys(policyDefinitions)) {
@@ -50051,7 +50142,7 @@ function scheduleRounds(params) {
     return { scheduledRounds };
 }
 
-var generate$1 = {
+var generate$2 = {
     __proto__: null,
     generateEventWithDraw: generateEventWithDraw,
     generateOutcome: generateOutcome,
@@ -50328,7 +50419,7 @@ function generatePairParticipantName({ individualParticipantIds, individualParti
 }
 
 function modifyTournamentRecord(params) {
-    const { ratingsParameters: ratingsParameters$1 = ratingsParameters, participantsProfile = {}, matchUpStatusProfile, completeAllMatchUps, autoEntryPositions, hydrateCollections, randomWinningSide, schedulingProfile, tournamentRecord, eventProfiles, periodLength, venueProfiles, autoSchedule, drawProfiles, uuids, } = 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 = [];
@@ -50436,6 +50527,7 @@ function modifyTournamentRecord(params) {
                         randomWinningSide,
                         tournamentRecord,
                         drawProfiles,
+                        isMock,
                         event,
                     });
                     if (result.error)
@@ -50526,7 +50618,7 @@ var mutate$6 = {
 var mocksGovernor = {
     __proto__: null,
     anonymizeTournamentRecord: anonymizeTournamentRecord,
-    generate: generate$1,
+    generate: generate$2,
     generateEventWithDraw: generateEventWithDraw,
     generateOutcome: generateOutcome,
     generateOutcomeFromScoreString: generateOutcomeFromScoreString,
@@ -55421,6 +55513,11 @@ var index$4 = {
     validateCollectionDefinition: validateCollectionDefinition
 };
 
+var generate$1 = {
+    __proto__: null,
+    createTournamentRecord: createTournamentRecord
+};
+
 const ABANDONED = 'ABANDONED';
 const ACTIVE = 'ACTIVE';
 const CANCELLED = 'CANCELLED';
@@ -55812,6 +55909,8 @@ var index$3 = {
     addTournamentTimeItem: addTournamentTimeItem,
     analyzeDraws: analyzeDraws,
     analyzeTournament: analyzeTournament,
+    createTournamentRecord: createTournamentRecord,
+    generate: generate$1,
     getAllowedDrawTypes: getAllowedDrawTypes,
     getAllowedMatchUpFormats: getAllowedMatchUpFormats,
     getAppliedPolicies: getAppliedPolicies,
@@ -57306,7 +57405,7 @@ function engineStart(engine, engineInvoke) {
     };
     engine.getDevContext = (contextCriteria) => getDevContext(contextCriteria);
     engine.newTournamentRecord = (params = {}) => {
-        const result = newTournamentRecord(params);
+        const result = createTournamentRecord(params);
         const tournamentId = result.tournamentId;
         if (result.error)
             return result;