tods-competition-factory 1.7.10 → 1.7.11

package/dist/index.mjs

@@ -333,7 +333,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.7.10";
+  return "1.7.11";
 }
 
 function getObjectTieFormat(obj) {
@@ -44424,6 +44424,16 @@ function generateAdHocMatchUps$1({
   );
   if (!structure)
     return { error: STRUCTURE_NOT_FOUND };
+  let structureHasRoundPositions;
+  const existingMatchUps = structure.matchUps ?? [];
+  const lastRoundNumber = existingMatchUps?.reduce(
+    (roundNumber2, matchUp) => {
+      if (matchUp.roundPosition)
+        structureHasRoundPositions = true;
+      return (matchUp?.roundNumber || 0) > roundNumber2 ? matchUp.roundNumber : roundNumber2;
+    },
+    0
+  );
   if (!matchUpsCount) {
     const selectedEntries = drawDefinition?.entries?.filter((entry) => {
       const entryStatus = entry.entryStatus;
@@ -44433,7 +44443,11 @@ function generateAdHocMatchUps$1({
     if (newRound) {
       matchUpsCount = roundMatchUpsCount;
     } else {
-      const maxRemaining = roundMatchUpsCount - (structure.matchUps?.length || 0);
+      const targetRoundNumber = roundNumber || lastRoundNumber || 1;
+      const existingRoundMatchUps = structure.matchUps?.filter(
+        (matchUp) => matchUp.roundNumber === targetRoundNumber
+      )?.length || 0;
+      const maxRemaining = roundMatchUpsCount - existingRoundMatchUps;
       if (maxRemaining > 0)
         matchUpsCount = maxRemaining;
     }
@@ -44441,16 +44455,6 @@ function generateAdHocMatchUps$1({
   if (participantIdPairings && !Array.isArray(participantIdPairings) || matchUpsCount && !isConvertableInteger(matchUpsCount) || matchUpIds && !Array.isArray(matchUpIds) || !participantIdPairings && !matchUpsCount) {
     return { error: INVALID_VALUES, info: "matchUpsCount or pairings error" };
   }
-  let structureHasRoundPositions;
-  const existingMatchUps = structure.matchUps ?? [];
-  const lastRoundNumber = existingMatchUps?.reduce(
-    (roundNumber2, matchUp) => {
-      if (matchUp.roundPosition)
-        structureHasRoundPositions = true;
-      return (matchUp?.roundNumber || 0) > roundNumber2 ? matchUp.roundNumber : roundNumber2;
-    },
-    0
-  );
   if (structure.structures || structureHasRoundPositions || structure.finishingPosition === ROUND_OUTCOME) {
     return { error: INVALID_STRUCTURE };
   }
@@ -45081,9 +45085,12 @@ function setPositionAssignments$1({
   return { ...SUCCESS };
 }
 
-function getAssignedParticipantIds({ drawDefinition, stages }) {
+function getAssignedParticipantIds({
+  drawDefinition,
+  stages
+}) {
   const stageStructures = (drawDefinition?.structures || []).filter(
-    (structure) => !stages?.length || stages.includes(structure.stage)
+    (structure) => !stages?.length || structure.stage && stages.includes(structure.stage)
   );
   return stageStructures.map((structure) => {
     const { positionAssignments } = getPositionAssignments$1({
@@ -45626,49 +45633,47 @@ function participantInFlightEntries({
 
 function removeEventEntries({
   autoEntryPositions = true,
-  tournamentParticipants,
-  tournamentRecord,
-  participantIds,
+  participantIds = [],
+  entryStatuses,
+  stage,
   event
 }) {
   const stack = "removeEventEntries";
   if (!event?.eventId)
     return { error: MISSING_EVENT };
-  if (!Array.isArray(participantIds))
-    return decorateResult({
-      result: { error: MISSING_PARTICIPANT_IDS },
-      stack
-    });
-  participantIds = participantIds?.filter(Boolean);
-  if (!participantIds?.length)
-    return decorateResult({
-      result: { error: MISSING_PARTICIPANT_IDS },
-      stack
-    });
-  const { eventId } = event;
-  if (!tournamentParticipants) {
-    tournamentParticipants = getTournamentParticipants({
-      participantFilters: { participantIds },
-      tournamentRecord,
-      withEvents: true,
-      withDraws: true
-    }).tournamentParticipants;
+  if (!Array.isArray(participantIds) || participantIds.some((participantId) => !isString(participantId))) {
+    return decorateResult({ result: { error: INVALID_PARTICIPANT_ID }, stack });
   }
-  const enteredParticipantIds = tournamentParticipants?.every((participant) => {
-    const eventObject = participant.events.find(
-      (event2) => event2.eventId === eventId
-    );
-    const drawIds = eventObject?.drawIds || [];
-    return participant.draws.filter(
-      (drawInfo) => drawIds.includes(drawInfo.drawId) && drawInfo.positionAssignments
-    ).length;
-  });
-  if (enteredParticipantIds) {
+  const assignedParticipantIds = (event.drawDefinitions ?? []).flatMap(
+    (drawDefinition) => getAssignedParticipantIds({ drawDefinition })
+  );
+  const statusParticipantIds = (entryStatuses?.length && event.entries?.filter(
+    (entry) => entry.entryStatus && entryStatuses.includes(entry.entryStatus)
+  ) || []).map(extractAttributes("participantId")).filter((participantId) => !assignedParticipantIds.includes(participantId));
+  const stageParticipantIds = (stage && event.entries?.filter(
+    (entry) => entry.entryStage && entry.entryStage === stage
+  ) || []).map(extractAttributes("participantId")).filter((participantId) => !assignedParticipantIds.includes(participantId));
+  if (participantIds.length) {
+    participantIds = participantIds.filter(
+      (participantId) => (!entryStatuses?.length || statusParticipantIds.includes(participantId)) && (!stage || stageParticipantIds.includes(participantId))
+    );
+  } else if (statusParticipantIds.length && stageParticipantIds.length) {
+    participantIds = intersection(statusParticipantIds, stageParticipantIds);
+  } else if (statusParticipantIds.length) {
+    participantIds = statusParticipantIds;
+  } else if (stageParticipantIds.length) {
+    participantIds = stageParticipantIds;
+  }
+  if (participantIds?.length && assignedParticipantIds.some(
+    (participantId) => participantIds.includes(participantId)
+  )) {
     return decorateResult({
       result: { error: EXISTING_PARTICIPANT_DRAW_POSITION_ASSIGNMENT },
       stack
     });
   }
+  if (!participantIds?.length)
+    return { ...SUCCESS, participantIdsRemoved: [] };
   const participantIdsRemoved = [];
   event.entries = (event.entries || []).filter((entry) => {
     const keepEntry = !participantIds.includes(entry?.participantId);
@@ -45826,7 +45831,6 @@ function addEventEntries(params) {
         participantIds: ungroupedParticipantIdsToRemove,
         autoEntryPositions: false,
         // because the method will be called below if necessary
-        tournamentRecord,
         event
       });
     }
@@ -46083,8 +46087,6 @@ function deleteParticipants(params) {
   const mappedIndividualParticipantIdsToAdd = {};
   for (const event of tournamentRecord.events || []) {
     const result = removeEventEntries({
-      tournamentParticipants,
-      tournamentRecord,
       participantIds,
       event
     });
@@ -46225,7 +46227,6 @@ function destroyGroupEntry({
   );
   let result = removeEventEntries({
     participantIds: [participantId],
-    tournamentRecord,
     event
   });
   if (result.error)