tods-competition-factory 1.7.9 → 1.7.11

package/dist/index.mjs

@@ -333,7 +333,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.7.9";
+  return "1.7.11";
 }
 
 function getObjectTieFormat(obj) {
@@ -3972,20 +3972,20 @@ function evaluateCollectionResult({
     if (matchUp.winningSide)
       sideWins[matchUp.winningSide - 1] += 1;
   });
-  if (matchUpValue) {
+  if (isConvertableInteger(matchUpValue)) {
     collectionMatchUps.forEach((matchUp) => {
       if (matchUp.winningSide) {
         sideMatchUpValues[matchUp.winningSide - 1] += matchUpValue;
       }
     });
-  } else if (setValue) {
+  } else if (isConvertableInteger(setValue)) {
     collectionMatchUps.forEach((matchUp) => {
       matchUp.score?.sets?.forEach((set) => {
         if (set.winningSide)
           sideMatchUpValues[set.winningSide - 1] += setValue;
       });
     });
-  } else if (scoreValue) {
+  } else if (isConvertableInteger(scoreValue)) {
     collectionMatchUps.forEach((matchUp) => {
       matchUp.score?.sets?.forEach((set) => {
         const {
@@ -4012,15 +4012,17 @@ function evaluateCollectionResult({
           collectionDefinition,
           collectionPosition
         });
-        sideMatchUpValues[matchUp.winningSide - 1] += matchUpValue2;
+        if (isConvertableInteger(matchUpValue2)) {
+          sideMatchUpValues[matchUp.winningSide - 1] += matchUpValue2;
+        }
       }
     });
   }
-  if (collectionValue) {
+  if (isConvertableInteger(collectionValue)) {
     let collectionWinningSide;
     if (winCriteria?.aggregateValue) {
       if (allCollectionMatchUpsCompleted) {
-        if ((matchUpValue || setValue || scoreValue) && sideMatchUpValues[0] !== sideMatchUpValues[1]) {
+        if (isConvertableInteger(matchUpValue || setValue || scoreValue) && sideMatchUpValues[0] !== sideMatchUpValues[1]) {
           collectionWinningSide = sideMatchUpValues[0] > sideMatchUpValues[1] ? 1 : 2;
         } else if (sideWins[0] !== sideWins[1]) {
           collectionWinningSide = sideWins[0] > sideWins[1] ? 1 : 2;
@@ -4056,7 +4058,7 @@ function evaluateCollectionResult({
   }
   if (!belongsToValueGroup) {
     sideCollectionValues.forEach(
-      (sideCollectionValue, i) => sideTieValues[i] += sideCollectionValue
+      (sideCollectionValue, i) => sideTieValues[i] += sideCollectionValue || 0
     );
   } else {
     groupValueGroups[collectionGroupNumber].sideWins[0] += sideWins[0] || 0;
@@ -8372,7 +8374,9 @@ function getGroupValueGroups({
 }) {
   const groupValueGroups = Object.assign(
     {},
-    ...collectionGroups.filter((group) => group?.groupValue && group?.groupNumber).map((group) => ({
+    ...collectionGroups.filter(
+      (group) => isConvertableInteger(group?.groupValue) && group?.groupNumber
+    ).map((group) => ({
       [group.groupNumber]: {
         ...group,
         allGroupMatchUpsCompleted: true,
@@ -8449,11 +8453,11 @@ function generateTieMatchUpScore(params) {
       }, void 0);
     }
     if (groupWinningSide) {
-      sideTieValues[groupWinningSide - 1] += groupValue;
+      sideTieValues[groupWinningSide - 1] += groupValue || 0;
     }
   }
   const sideScores = sideTieValues.map(
-    (sideTieValue, i) => sideTieValue + sideAdjustments[i]
+    (sideTieValue, i) => (sideTieValue || 0) + sideAdjustments[i]
   );
   const set = {
     side1Score: sideScores[0],
@@ -15120,20 +15124,18 @@ function calculateWinCriteria({
       setValue
     } = collectionDefinition;
     const belongsToValueGroup = collectionGroupNumber && groupValueNumbers.includes(collectionGroupNumber);
-    if (setValue || scoreValue) {
+    if (isConvertableInteger(setValue || scoreValue)) {
       aggregateValueImperative = true;
     } else if (belongsToValueGroup) {
       continue;
-    } else if (collectionValue) {
+    } else if (typeof collectionValue === "number" && isConvertableInteger(collectionValue)) {
       valueTotal += collectionValue;
     } else if (collectionValueProfiles?.length) {
       for (const collectionValueProfile of collectionValueProfiles) {
         valueTotal += collectionValueProfile.matchUpValue;
       }
-    } else if (matchUpValue) {
+    } else if (typeof matchUpValue === "number" && isConvertableInteger(matchUpValue)) {
       valueTotal += (matchUpCount || 0) * matchUpValue;
-    } else {
-      valueTotal += matchUpCount || 0;
     }
   }
   for (const collectionGroup of collectionGroups) {
@@ -44422,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;
@@ -44431,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;
     }
@@ -44439,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 };
   }
@@ -45079,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({
@@ -45624,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);
@@ -45824,7 +45831,6 @@ function addEventEntries(params) {
         participantIds: ungroupedParticipantIdsToRemove,
         autoEntryPositions: false,
         // because the method will be called below if necessary
-        tournamentRecord,
         event
       });
     }
@@ -46081,8 +46087,6 @@ function deleteParticipants(params) {
   const mappedIndividualParticipantIdsToAdd = {};
   for (const event of tournamentRecord.events || []) {
     const result = removeEventEntries({
-      tournamentParticipants,
-      tournamentRecord,
       participantIds,
       event
     });
@@ -46223,7 +46227,6 @@ function destroyGroupEntry({
   );
   let result = removeEventEntries({
     participantIds: [participantId],
-    tournamentRecord,
     event
   });
   if (result.error)