tods-competition-factory 1.7.10 → 1.7.12

package/dist/index.mjs

@@ -333,7 +333,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.7.10";
+  return "1.7.12";
 }
 
 function getObjectTieFormat(obj) {
@@ -16620,7 +16620,6 @@ function compareTieFormats({
   );
   const nameDifference = !!(considerations?.collectionName && descendant.collectionDefinitions.map(({ collectionName }) => collectionName).join("|") !== ancestor.collectionDefinitions.map(({ collectionName }) => collectionName).join("|"));
   const orderDifference = !!(considerations?.collectionOrder && descendant.collectionDefinitions.map(({ collectionOrder }) => collectionOrder).join("|") !== ancestor.collectionDefinitions.map(({ collectionOrder }) => collectionOrder).join("|"));
-  const different = nameDifference || orderDifference || ancestorDesc !== descendantDesc;
   const descendantCollectionDefinitions = Object.assign(
     {},
     ...(descendant?.collectionDefinitions || []).map(
@@ -16644,17 +16643,16 @@ function compareTieFormats({
     Object.keys(descendantCollectionDefinitions)
   );
   descendantDifferences.collectionsValue = getCollectionsValue(
-    descendantCollectionDefinitions,
-    descendantDifferences
+    descendantCollectionDefinitions
   );
   ancestorDifferences.collectionsValue = getCollectionsValue(
-    ancestorCollectionDefinitions,
-    ancestorDifferences
+    ancestorCollectionDefinitions
   );
   descendantDifferences.groupsCount = ancestor?.collectionGroups?.length ?? (0 - (descendant?.collectionGroups?.length ?? 0) || 0);
   ancestorDifferences.groupsCount = descendantDifferences.groupsCount ? -1 * descendantDifferences.groupsCount : 0;
   const valueDifference = descendantDifferences.collectionsValue.totalValue - ancestorDifferences.collectionsValue.totalValue;
   const matchUpCountDifference = descendantDifferences.collectionsValue.totalMatchUps - ancestorDifferences.collectionsValue.totalMatchUps;
+  const different = nameDifference || orderDifference || ancestorDesc !== descendantDesc || valueDifference !== 0;
   return {
     matchUpFormatDifferences,
     matchUpCountDifference,
@@ -16669,15 +16667,18 @@ function compareTieFormats({
     different
   };
 }
-function getCollectionsValue(definitions, aggregator) {
+function getCollectionsValue(definitions) {
   let totalMatchUps = 0;
-  const totalValue = aggregator.collectionIds.reduce((total, collectionId) => {
+  const collectionIds = Object.keys(definitions);
+  const totalValue = collectionIds.reduce((total, collectionId) => {
     const collectionDefinition = definitions[collectionId];
     const {
       collectionValueProfiles,
       collectionValue,
       matchUpCount,
-      matchUpValue
+      matchUpValue,
+      scoreValue,
+      setValue
     } = collectionDefinition;
     totalMatchUps += matchUpCount;
     if (collectionValueProfiles)
@@ -16685,9 +16686,16 @@ function getCollectionsValue(definitions, aggregator) {
         (total2, profile) => total2 + profile.value,
         0
       );
-    if (matchUpValue && matchUpCount)
-      return total + matchUpValue * matchUpCount;
-    return total + collectionValue;
+    if (matchUpCount) {
+      if (isConvertableInteger(matchUpValue))
+        return total + matchUpValue * matchUpCount;
+      if (isConvertableInteger(scoreValue))
+        return total + scoreValue * matchUpCount;
+      if (isConvertableInteger(setValue))
+        return total + setValue * matchUpCount;
+      return total + collectionValue;
+    }
+    return total;
   }, 0);
   return { totalValue, totalMatchUps };
 }
@@ -44424,6 +44432,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 +44451,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 +44463,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 +45093,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 +45641,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 +45839,6 @@ function addEventEntries(params) {
         participantIds: ungroupedParticipantIdsToRemove,
         autoEntryPositions: false,
         // because the method will be called below if necessary
-        tournamentRecord,
         event
       });
     }
@@ -46083,8 +46095,6 @@ function deleteParticipants(params) {
   const mappedIndividualParticipantIdsToAdd = {};
   for (const event of tournamentRecord.events || []) {
     const result = removeEventEntries({
-      tournamentParticipants,
-      tournamentRecord,
       participantIds,
       event
     });
@@ -46225,7 +46235,6 @@ function destroyGroupEntry({
   );
   let result = removeEventEntries({
     participantIds: [participantId],
-    tournamentRecord,
     event
   });
   if (result.error)
@@ -60245,6 +60254,7 @@ var lastNames = [
 	"Dallas",
 	"Diamond",
 	"Deckard",
+	"Dunbar",
 	"Earhart",
 	"Eisenstein",
 	"Eldritch",