tods-competition-factory 2.1.16 → 2.1.18

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

@@ -2711,12 +2711,13 @@ declare function qualifierDrawPositionAssignment(params: any): ResultType | {
     };
 };
 
-declare function alternateDrawPositionAssignment({ alternateParticipantId, tournamentRecord, drawDefinition, drawPosition, structureId, }: {
+declare function alternateDrawPositionAssignment({ alternateParticipantId, tournamentRecord, drawDefinition, drawPosition, structureId, event, }: {
     alternateParticipantId: any;
     tournamentRecord: any;
     drawDefinition: any;
     drawPosition: any;
     structureId: any;
+    event: any;
 }): ResultType | {
     error: {
         message: string;
@@ -4200,13 +4201,13 @@ type ModifyEventEntriesArgs = {
 };
 declare function modifyEventEntries({ entryStatus, unpairedParticipantIds, participantIdPairs, entryStage, tournamentRecord, event, }: ModifyEventEntriesArgs): any;
 
-declare function addDrawEntries({ suppressDuplicateEntries, autoEntryPositions, entryStageSequence, ignoreStageSpace, drawDefinition, participantIds, entryStatus, roundTarget, entryStage, extension, drawId, event, }: {
+declare function addDrawEntries({ suppressDuplicateEntries, autoEntryPositions, entryStageSequence, ignoreStageSpace, participantIds, drawDefinition, entryStatus, roundTarget, entryStage, extension, drawId, event, }: {
     suppressDuplicateEntries?: boolean | undefined;
     autoEntryPositions?: boolean | undefined;
     entryStageSequence: any;
     ignoreStageSpace: any;
-    drawDefinition: any;
     participantIds: any;
+    drawDefinition: any;
     entryStatus: any;
     roundTarget: any;
     entryStage: any;
@@ -4451,15 +4452,7 @@ declare function refreshEventDrawOrder({ tournamentRecord, event }: {
     info?: undefined;
 };
 
-declare function modifyPairAssignment({ replacementIndividualParticipantId, existingIndividualParticipantId, tournamentRecord, drawDefinition, participantId, event, uuids, }: {
-    replacementIndividualParticipantId: any;
-    existingIndividualParticipantId: any;
-    tournamentRecord: any;
-    drawDefinition: any;
-    participantId: any;
-    event: any;
-    uuids: any;
-}): any;
+declare function modifyPairAssignment(params: any): any;
 
 declare function updateDrawIdsOrder({ event, orderedDrawIdsMap }: {
     event: any;
@@ -6593,7 +6586,12 @@ declare function modifyPenalty(params: any): {
     };
 };
 
-declare function deleteParticipants(params: any): {
+type DeleteParticipantsArgs = {
+    addIndividualParticipantsToEvents?: boolean;
+    tournamentRecord: Tournament;
+    participantIds: string[];
+};
+declare function deleteParticipants(params: DeleteParticipantsArgs): {
     participantsRemovedCount?: number;
     success?: boolean;
     error?: ErrorType;

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.1.16';
+    return '2.1.18';
 }
 
 const SINGLES_MATCHUP = 'SINGLES';
@@ -4442,6 +4442,7 @@ const ONE_OF = '_oneOf';
 const validators = {
     [ONLINE_RESOURCE]: (value) => intersection(Object.keys(value), [RESOURCE_SUB_TYPE, RESOURCE_TYPE, IDENTIFIER]).length === 3,
     [TIE_FORMAT_NAME]: (value) => value && tieFormatDefaults({ namedFormat: value }),
+    [UUIDS]: (value) => !value || (Array.isArray(value) && value.every(isString)),
     [TIE_FORMAT]: (value) => !validateTieFormat({ tieFormat: value }).error,
     [EVENT_TYPE]: (value) => [SINGLES, DOUBLES, TEAM$1].includes(value),
     [ENTRY_STAGE]: (value) => validStages.includes(value),
@@ -10363,9 +10364,8 @@ function addMatchUpContext({ scheduleVisibilityFilters, sourceDrawPositionRanges
                 if (participant) {
                     if (drawDefinition?.entries) {
                         const entry = drawDefinition.entries.find((entry) => entry.participantId === side.participantId);
-                        if (entry?.entryStatus) {
-                            participant.entryStatus = entry.entryStatus;
-                        }
+                        const eEntry = event?.entries?.find((entry) => entry.participantId === side.participantId);
+                        participant.entryStatus = entry?.entryStatus || eEntry?.entryStatus;
                         if (entry?.entryStage) {
                             participant.entryStage = entry.entryStage;
                         }
@@ -13849,11 +13849,11 @@ function getParticipantEntries(params) {
             const drawIds = unique([...drawDefinitions.map(getDrawId), ...flights.map(getDrawId)]);
             for (const drawId of drawIds) {
                 const drawDefinition = drawDefinitions.find((drawDefinition) => drawDefinition.drawId === drawId);
+                const scaleNames = [category?.categoryName, category?.ageCategoryCode].filter(Boolean);
+                const { structures = [], drawOrder, drawName, drawType } = drawDefinition ?? {};
                 const flight = flights?.find((flight) => flight.drawId === drawId);
                 const entries = drawDefinition?.entries || flight?.drawEntries;
-                const { structures = [], drawOrder, drawName, drawType } = drawDefinition ?? {};
                 const flightNumber = flight?.flightNumber;
-                const scaleNames = [category?.categoryName, category?.ageCategoryCode].filter(Boolean);
                 const orderedStructureIds = (drawDefinition?.structures || [])
                     .sort((a, b) => structureSort(a, b))
                     .map(({ structureId, structures }) => {
@@ -14727,7 +14727,7 @@ function addDrawEntries$1(params) {
         : { ...SUCCESS };
 }
 
-function addDrawEntries({ suppressDuplicateEntries = true, autoEntryPositions = true, entryStageSequence, ignoreStageSpace, drawDefinition, participantIds, entryStatus, roundTarget, entryStage, extension, drawId, event, }) {
+function addDrawEntries({ suppressDuplicateEntries = true, autoEntryPositions = true, entryStageSequence, ignoreStageSpace, participantIds, drawDefinition, entryStatus, roundTarget, entryStage, extension, drawId, event, }) {
     if (!participantIds?.length)
         return { error: MISSING_PARTICIPANT_IDS };
     if (!event)
@@ -14745,8 +14745,8 @@ function addDrawEntries({ suppressDuplicateEntries = true, autoEntryPositions =
             autoEntryPositions,
             stage: entryStage,
             ignoreStageSpace,
-            drawDefinition,
             participantIds,
+            drawDefinition,
             entryStatus,
             roundTarget,
             extension,
@@ -15231,10 +15231,12 @@ function removeParticipantIdsFromAllTeams({ participantRole = COMPETITOR, indivi
 }
 
 function deleteParticipants(params) {
-    if (!params?.tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    if (!params?.participantIds?.length)
-        return { error: MISSING_PARTICIPANT_IDS };
+    const paramsCheck = checkRequiredParameters(params, [
+        { [TOURNAMENT_RECORD]: true },
+        { participantIds: true, [OF_TYPE]: ARRAY, [ERROR]: MISSING_PARTICIPANT_IDS },
+    ]);
+    if (paramsCheck.error)
+        return paramsCheck;
     const { addIndividualParticipantsToEvents, tournamentRecord, participantIds } = params;
     const participantsCount = tournamentRecord.participants?.length || 0;
     if (!participantsCount)
@@ -15248,18 +15250,17 @@ function deleteParticipants(params) {
         tournamentRecord,
         withDraws: true,
     }).participants ?? [];
-    const getPlacedPairParticipantIds = () => {
+    const getPlacedPairParticipantIds = (teamDrawIds) => {
         const matchUps = allTournamentMatchUps({
             matchUpFilters: { drawIds: teamDrawIds, matchUpTypes: [DOUBLES$1] },
             tournamentRecord,
         }).matchUps ?? [];
         const placedPairParticipantIds = matchUps
-            .map(({ sides }) => sides?.map(({ participantId }) => participantId))
-            .flat()
+            .flatMap(({ sides }) => sides?.map(({ participantId }) => participantId || []))
             .filter(Boolean);
         return intersection(placedPairParticipantIds, participantIds);
     };
-    const placedPairParticipantIds = teamDrawIds?.length && getPlacedPairParticipantIds();
+    const placedPairParticipantIds = teamDrawIds?.length ? getPlacedPairParticipantIds(teamDrawIds) : [];
     const participantsInDraws = tournamentParticipants.filter((participant) => participant.draws?.filter((drawInfo) => (!teamDrawIds?.length || !teamDrawIds?.includes(drawInfo.drawId)) && drawInfo.positionAssignments).length);
     if (placedPairParticipantIds?.length || participantsInDraws.length) {
         return { error: EXISTING_PARTICIPANT_DRAW_POSITION_ASSIGNMENT };
@@ -15275,17 +15276,18 @@ function deleteParticipants(params) {
             return result;
         eventParticipantIdsRemoved[event.eventId] = result.participantIdsRemoved;
     }
-    tournamentRecord.participants = tournamentRecord.participants.filter((participant) => {
+    tournamentRecord.participants = (tournamentRecord.participants ?? []).filter((participant) => {
         const participantToRemove = participantIds.includes(participant.participantId) ||
             (participant.participantType === PAIR &&
-                participant.individualParticipantIds.some((id) => participantIds.includes(id)));
+                participant.individualParticipantIds?.some((id) => participantIds.includes(id)));
         if (!participantToRemove &&
             participant.participantType === TEAM$1 &&
-            participant.individualParticipantIds.some((id) => participantIds.includes(id))) {
+            participant.individualParticipantIds?.some((id) => participantIds.includes(id))) {
             participant.individualParticipantIds = participant.individualParticipantIds.filter((id) => !participantIds.includes(id));
         }
         if (participantToRemove &&
             addIndividualParticipantsToEvents &&
+            participant.participantType &&
             [PAIR, TEAM].includes(participant.participantType)) {
             for (const individualParticipantId of participant.individualParticipantIds || []) {
                 if (!participantIds.includes(individualParticipantId)) {
@@ -17035,6 +17037,18 @@ function assignDrawPosition$1({ provisionalPositioning, inContextDrawMatchUps, i
             });
         }
     }
+    const drawEntry = drawDefinition.entries?.find((entry) => entry.participantId === participantId);
+    const eventEntry = event?.entries?.find((entry) => entry.participantId === participantId);
+    if (!drawEntry && eventEntry) {
+        addDrawEntry({
+            entryStatus: eventEntry.entryStatus,
+            entryStage: structure.stage,
+            ignoreStageSpace: true,
+            drawDefinition,
+            participantId,
+            event,
+        });
+    }
     modifyPositionAssignmentsNotice({
         tournamentId: tournamentRecord?.tournamentId,
         drawDefinition,
@@ -17379,7 +17393,7 @@ function qualifierDrawPositionAssignment(params) {
     return qualifierDrawPositionAssignment$1(params);
 }
 
-function alternateDrawPositionAssignment({ alternateParticipantId, tournamentRecord, drawDefinition, drawPosition, structureId, }) {
+function alternateDrawPositionAssignment({ alternateParticipantId, tournamentRecord, drawDefinition, drawPosition, structureId, event, }) {
     return positionParticipantAction({
         positionActionName: 'alternateDrawPositionAssignment',
         participantIdAttributeName: 'alternateParticipantid',
@@ -17388,6 +17402,7 @@ function alternateDrawPositionAssignment({ alternateParticipantId, tournamentRec
         drawDefinition,
         drawPosition,
         structureId,
+        event,
     });
 }
 
@@ -24764,12 +24779,19 @@ function deleteAdHocMatchUps(params) {
                 .flatMap((matchUp) => (matchUp.sides ?? []).map((side) => side.participantId))
                 .filter(Boolean)).map((participantId) => ({ participantId }));
             const matchUpFormat = structure?.matchUpFormat ?? drawDefinition?.matchUpFormat ?? event?.matchUpFormat;
+            const isDualMatchUp = structureResult.existingMatchUps.some((matchUp) => matchUp.matchUpType === TEAM_MATCHUP);
+            const matchUpFilters = isDualMatchUp ? { matchUpTypes: [TEAM_MATCHUP] } : undefined;
             const { matchUps } = getAllStructureMatchUps({
                 afterRecoveryTimes: false,
                 inContext: true,
+                matchUpFilters,
                 structure,
                 event,
             });
+            const isAdHocStructure = isAdHoc({ structure });
+            if (isAdHocStructure) {
+                structure.positionAssignments = unique(matchUps.flatMap((matchUp) => (matchUp.sides ?? []).map((side) => side.participantId)).filter(Boolean)).map((participantId) => ({ participantId }));
+            }
             const result = updateAssignmentParticipantResults({
                 positionAssignments: structure.positionAssignments,
                 tournamentRecord,
@@ -25651,9 +25673,7 @@ function getValidAlternatesAction({ tournamentParticipants = [], possiblyDisabli
         .sort((a, b) => (a.entryPosition ?? Infinity) - (b.entryPosition ?? Infinity))
         .map(({ participantId }) => participantId)
         .filter(Boolean);
-    const { allPositionedParticipantIds } = getAllPositionedParticipantIds({
-        drawDefinition,
-    });
+    const { allPositionedParticipantIds } = getAllPositionedParticipantIds({ drawDefinition });
     const assignedParticipantIds = positionAssignments.map((assignment) => assignment.participantId).filter(Boolean);
     const availableDrawEnteredParticipantIds = drawEnteredParticipantIds.filter((participantId) => structure.stage && [QUALIFYING, MAIN, PLAY_OFF].includes(structure.stage)
         ? !allPositionedParticipantIds?.includes(participantId)
@@ -34805,9 +34825,8 @@ function getDrawData(params) {
             if (structure.stage && [MAIN, CONSOLATION, PLAY_OFF].includes(structure.stage)) {
                 seedAssignments = mainStageSeedAssignments;
             }
-            if (structure?.stage === QUALIFYING) {
+            if (structure?.stage === QUALIFYING)
                 seedAssignments = qualificationStageSeedAssignments;
-            }
             const { matchUps, roundMatchUps, roundProfile } = getAllStructureMatchUps({
                 seedAssignments: !structure?.seedAssignments?.length ? seedAssignments : undefined,
                 context: { drawId: drawInfo.drawId, ...context },
@@ -34821,9 +34840,7 @@ function getDrawData(params) {
                 structure,
                 event,
             });
-            const { positionAssignments } = getPositionAssignments$1({
-                structure,
-            });
+            const { positionAssignments } = getPositionAssignments$1({ structure });
             let participantResults = positionAssignments?.filter(xa(PARTICIPANT_ID)).map((assignment) => {
                 const participantResult = findExtension({ element: assignment, name: TALLY })?.extension?.value;
                 const { drawPosition, participantId } = assignment;
@@ -34838,12 +34855,16 @@ function getDrawData(params) {
                 ((!participantResults?.length && params.allParticipantResults) ||
                     (refreshResults && !structure.structures))) {
                 const { subOrderMap } = createSubOrderMap({ positionAssignments });
+                const hasTeamMatchUps = matchUps.some((matchUp) => matchUp.matchUpType === TEAM_MATCHUP);
+                const consideredMatchUps = hasTeamMatchUps
+                    ? matchUps.filter((matchUp) => matchUp.matchUpType === TEAM_MATCHUP)
+                    : matchUps;
                 const result = tallyParticipantResults({
                     matchUpFormat: structure.matchUpFormat,
+                    matchUps: consideredMatchUps,
                     policyDefinitions,
                     pressureRating,
                     subOrderMap,
-                    matchUps,
                 });
                 participantResults = positionAssignments?.filter(xa(PARTICIPANT_ID)).map((assignment) => {
                     const { drawPosition, participantId } = assignment;
@@ -39901,18 +39922,22 @@ function deleteFlightAndFlightDraw({ autoPublish = true, tournamentRecord, audit
     return refreshEventDrawOrder({ tournamentRecord, event });
 }
 
-function modifyPairAssignment({ replacementIndividualParticipantId, existingIndividualParticipantId, tournamentRecord, drawDefinition, participantId, event, uuids, }) {
-    if (!event)
-        return { error: MISSING_EVENT };
+function modifyPairAssignment(params) {
+    const paramsCheck = checkRequiredParameters(params, [
+        { [EVENT]: true, [TOURNAMENT_RECORD]: true, [UUIDS]: false },
+        {
+            replacementIndividualParticipantId: true,
+            [VALIDATE]: (value) => isString(value),
+            existingIndividualParticipantId: true,
+            [ERROR]: MISSING_PARTICIPANT_ID,
+            participantId: true,
+        },
+    ]);
+    const { replacementIndividualParticipantId, existingIndividualParticipantId, tournamentRecord, drawDefinition, participantId, event, uuids, } = params;
+    if (paramsCheck.error)
+        return paramsCheck;
     if (event?.eventType !== DOUBLES)
         return { error: INVALID_EVENT_TYPE };
-    if (uuids && !Array.isArray(uuids))
-        return { error: INVALID_VALUES };
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    if (![replacementIndividualParticipantId, existingIndividualParticipantId, participantId].every((id) => typeof id === 'string')) {
-        return { error: MISSING_PARTICIPANT_ID };
-    }
     const availableIndividualParticipantIds = event?.entries
         ?.filter(({ entryStatus }) => [UNGROUPED, UNPAIRED].includes(entryStatus))
         .map(({ participantId }) => participantId) || [];
@@ -39959,18 +39984,19 @@ function modifyPairAssignment({ replacementIndividualParticipantId, existingIndi
         }
         drawDefinition.entries = drawDefinition.entries.map((entry) => entry.participantId === participantId ? { ...entry, participantId: newPairParticipantId } : entry);
         for (const structure of drawDefinition.structures || []) {
-            if (structure.positionAssignments) {
-                structure.positionAssignments = structure.positionAssignments.map((assignment) => assignment.participantId === participantId
-                    ? { ...assignment, participantId: newPairParticipantId }
-                    : assignment);
-            }
-            else if (structure.structures) {
+            if (structure.structures) {
+                structure.positionAssignments = undefined;
                 for (const subStructure of structure.structures) {
                     subStructure.positionAssignments = subStructure.positionAssignments.map((assignment) => assignment.participantId === participantId
                         ? { ...assignment, participantId: newPairParticipantId }
                         : assignment);
                 }
             }
+            else if (structure.positionAssignments) {
+                structure.positionAssignments = structure.positionAssignments.map((assignment) => assignment.participantId === participantId
+                    ? { ...assignment, participantId: newPairParticipantId }
+                    : assignment);
+            }
         }
     }
     event.entries = event.entries.map((entry) => (entry.participantId === participantId && {
@@ -40428,7 +40454,9 @@ function modifyEvent(params) {
     const enteredParticipants = getEnteredParticipants(params);
     const participantsProfile = getParticipantsProfile({ enteredParticipants });
     const { enteredParticipantGenders, enteredParticipantTypes } = participantsProfile;
-    const genderResult = checkGenderUpdates({ enteredParticipantGenders, eventUpdates, stack });
+    const flights = getFlightProfile({ event })?.flightProfile?.flights;
+    const noFlightsNoDraws = !event.drawDefinitions?.length && !flights?.length;
+    const genderResult = checkGenderUpdates({ noFlightsNoDraws, enteredParticipantGenders, eventUpdates, stack });
     if (genderResult.error)
         return genderResult;
     const eventTypeResult = checkEventType({ enteredParticipantTypes, eventUpdates, stack });
@@ -40543,10 +40571,12 @@ function getParticipantsProfile({ enteredParticipants }) {
     const enteredParticipantGenders = unique(genderAccumulator);
     return { enteredParticipantTypes, enteredParticipantGenders };
 }
-function checkGenderUpdates({ enteredParticipantGenders, eventUpdates, stack }) {
+function checkGenderUpdates({ noFlightsNoDraws, enteredParticipantGenders, eventUpdates, stack }) {
     const validGender = !enteredParticipantGenders.length ||
-        [MIXED, ANY].includes(eventUpdates.gender ?? '') ||
-        (enteredParticipantGenders.length === 1 && enteredParticipantGenders[0] === eventUpdates.gender);
+        !eventUpdates.gender ||
+        eventUpdates.gender === ANY ||
+        (enteredParticipantGenders.length === 1 && enteredParticipantGenders[0] === eventUpdates.gender) ||
+        (noFlightsNoDraws && eventUpdates.gender === MIXED);
     return eventUpdates.gender && !validGender
         ? decorateResult({
             context: { gender: eventUpdates.gender, validGender },