tods-competition-factory 1.8.34 → 1.8.36

package/dist/index.mjs

@@ -2404,7 +2404,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.8.34";
+  return "1.8.36";
 }
 
 function getObjectTieFormat(obj) {
@@ -15542,7 +15542,13 @@ const POLICY_SEEDING_USTA = {
     validSeedPositions: { ignore: true },
     duplicateSeedNumbers: true,
     drawSizeProgression: true,
-    seedingProfile: { positioning: SEPARATE },
+    seedingProfile: {
+      drawTypes: {
+        [ROUND_ROBIN_WITH_PLAYOFF]: { positioning: WATERFALL },
+        [ROUND_ROBIN]: { positioning: WATERFALL }
+      },
+      positioning: SEPARATE
+    },
     policyName: "USTA SEEDING",
     seedsCountThresholds: [
       { drawSize: 4, minimumParticipantCount: 3, seedsCount: 2 },
@@ -19573,6 +19579,15 @@ function tidyScore(params) {
   };
 }
 
+function capitalizeFirst(str) {
+  return !isString(str) ? str : str.split(" ").map(
+    (name) => name.split("").map((c, i) => i ? c.toLowerCase() : c.toUpperCase()).join("")
+  ).join(" ");
+}
+function constantToString(str) {
+  return !isString(str) ? str : capitalizeFirst(str.replace(/_/g, " "));
+}
+
 const { FACTORY } = extensionConstants;
 function updateFactoryExtension({ tournamentRecord, value }) {
   const { extension } = findExtension({
@@ -23469,15 +23484,6 @@ function getNumericSeedValue(seedValue) {
   return Infinity;
 }
 
-function capitalizeFirst(str) {
-  return !isString(str) ? str : str.split(" ").map(
-    (name) => name.split("").map((c, i) => i ? c.toLowerCase() : c.toUpperCase()).join("")
-  ).join(" ");
-}
-function constantToString(str) {
-  return !isString(str) ? str : capitalizeFirst(str.replace(/_/g, " "));
-}
-
 const structureTemplate = ({
   finishingPosition = ROUND_OUTCOME,
   qualifyingRoundNumber,
@@ -27542,12 +27548,11 @@ function getParticipantEntries(params) {
   const targetParticipantIds = participantFilters?.participantIds;
   const getRelevantParticipantIds = (participantId) => {
     const relevantParticipantIds = [participantId];
-    relevantParticipantIds.push(participantId);
     participantMap[participantId]?.participant.individualParticipantIds?.forEach(
       (individualParticiapntId) => relevantParticipantIds.push(individualParticiapntId)
     );
     return relevantParticipantIds.some(
-      (obj) => !targetParticipantIds?.length || targetParticipantIds.includes(obj.relevantParticipantId)
+      (id) => !targetParticipantIds?.length || targetParticipantIds.includes(id)
     ) ? relevantParticipantIds : [];
   };
   const withOpts = {
@@ -41807,11 +41812,11 @@ function swapAssignedPositions({
   );
   const secondAssignment = candidatePositionAssignments.find(
     (assignment) => assignment.drawPosition === secondPosition
-  );
+  ) ?? {};
   const updatedFirstAssignmentAttributes = {
-    participantId: secondAssignment.participantId,
-    qualifier: secondAssignment.qualifier,
-    bye: secondAssignment.bye
+    participantId: secondAssignment?.participantId,
+    qualifier: secondAssignment?.qualifier,
+    bye: secondAssignment?.bye
   };
   const updatedSecondAssignmentAttributes = {
     participantId: firstAssignment.participantId,
@@ -41969,7 +41974,7 @@ function randomUnseededSeparation({
       });
       if (result.error)
         return decorateResult({ result, stack });
-    } else {
+    } else if (assignment.participantId) {
       const result = assignDrawPosition$1({
         automaticPlacement: true,
         inContextDrawMatchUps,
@@ -44555,7 +44560,7 @@ function removeStructure({
     drawDefinition.links = drawDefinition.links?.filter(
       (link) => link.source.structureId !== idBeingRemoved && link.target.structureId !== idBeingRemoved
     ) || [];
-    if (!isMainStageSequence1 || idBeingRemoved !== structureId) {
+    if (!isMainStageSequence1 || isMainStageSequence1 && qualifyingStructureIds.length || idBeingRemoved !== structureId) {
       drawDefinition.structures = (drawDefinition.structures ?? []).filter(
         (structure3) => {
           if (idBeingRemoved && idBeingRemoved === structure3.structureId)
@@ -45922,7 +45927,7 @@ function addEventEntries(params) {
   const genderEnforced = (enforceGender ?? matchUpActionsPolicy?.participants?.enforceGender) !== false;
   const addedParticipantIdEntries = [];
   const removedEntries = [];
-  if (extensions && (!Array.isArray(extensions) || !extensions.every(isValidExtension)) || extension && !isValidExtension({ extension })) {
+  if (extensions && (!Array.isArray(extensions) || !extensions.every((extension2) => isValidExtension({ extension: extension2 }))) || extension && !isValidExtension({ extension })) {
     return decorateResult({
       context: definedAttributes({ extension, extensions }),
       result: { error: INVALID_VALUES },
@@ -45984,7 +45989,7 @@ function addEventEntries(params) {
       if (entryStageSequence)
         entry.entryStageSequence = entryStageSequence;
       addedParticipantIdEntries.push(entry.participantId);
-      event.entries.push(entry);
+      event.entries && event.entries.push(entry);
     }
   });
   if (drawId && !isUngrouped(entryStage)) {
@@ -46005,14 +46010,14 @@ function addEventEntries(params) {
       info = result.error;
     }
   }
-  if ([DOUBLES$1, TEAM].includes(event.eventType)) {
+  if (event.eventType && [TypeEnum.Doubles, TypeEnum.Team].includes(event.eventType)) {
     const enteredParticipantIds = (event.entries || []).map(
       (entry) => entry.participantId
     );
     const ungroupedIndividualParticipantIds = (event.entries || []).filter((entry) => isUngrouped(entry.entryStatus)).map((entry) => entry.participantId);
     const tournamentParticipants = tournamentRecord?.participants || [];
     const groupedIndividualParticipantIds = tournamentParticipants.filter(
-      (participant) => enteredParticipantIds.includes(participant.participantId) && [PAIR, TEAM].includes(participant.participantType)
+      (participant) => enteredParticipantIds.includes(participant.participantId) && participant.participantType && [PAIR, TEAM].includes(participant.participantType)
     ).map((participant) => participant.individualParticipantIds).flat(Infinity);
     const ungroupedParticipantIdsToRemove = ungroupedIndividualParticipantIds.filter(
       (participantId) => groupedIndividualParticipantIds.includes(participantId)
@@ -56245,7 +56250,8 @@ function deleteDrawDefinitions({
   drawIds = [],
   auditData,
   eventId,
-  event
+  event,
+  force
 }) {
   if (!tournamentRecord)
     return { error: MISSING_TOURNAMENT_RECORD };
@@ -56291,9 +56297,18 @@ function deleteDrawDefinitions({
     qualifier,
     bye
   }) => ({ bye, qualifier, drawPosition, participantId });
+  const drawIdsWithScoresPresent = [];
   const filteredDrawDefinitions = event.drawDefinitions.filter(
     (drawDefinition) => {
       if (drawIds.includes(drawDefinition.drawId)) {
+        const matchUps = allDrawMatchUps$1({ event, drawDefinition })?.matchUps ?? [];
+        const scoresPresent = matchUps.some(
+          ({ score }) => scoreHasValue({ score })
+        );
+        if (scoresPresent && !force) {
+          drawIdsWithScoresPresent.push(drawDefinition.drawId);
+          return true;
+        }
         const { drawId: drawId2, drawType, drawName } = drawDefinition;
         const flight = flightProfile?.flights?.find(
           (flight2) => flight2.drawId === drawDefinition.drawId
@@ -56353,12 +56368,18 @@ function deleteDrawDefinitions({
             drawId: drawId2
           })
         );
-        const { matchUps } = allDrawMatchUps$1({ event, drawDefinition });
         matchUps?.forEach(({ matchUpId }) => matchUpIds.push(matchUpId));
       }
       return !drawIds.includes(drawDefinition.drawId);
     }
   );
+  if (drawIdsWithScoresPresent.length && !force) {
+    return decorateResult({
+      context: { drawIdsWithScoresPresent },
+      result: { error: SCORES_PRESENT },
+      stack
+    });
+  }
   event.drawDefinitions = filteredDrawDefinitions;
   if (flightProfile) {
     const extension = {
@@ -56580,24 +56601,39 @@ function addEventEntryPairs({
     return { error: MISSING_EVENT };
   if (event.eventType !== DOUBLES$1)
     return { error: INVALID_EVENT_TYPE };
-  const tournamentParticipants = tournamentRecord.participants ?? [];
-  const individualParticipantIds = tournamentParticipants.filter((participant) => participant.participantType === INDIVIDUAL).map((participant) => participant.participantId);
-  const invalidParticipantIds = individualParticipantIds.filter(
-    (participantId) => !individualParticipantIds.includes(participantId)
-  );
-  if (invalidParticipantIds.length)
-    return { error: INVALID_PARTICIPANT_IDS, invalidParticipantIds };
-  const invalidParticipantIdPairs = participantIdPairs.filter(
-    (pair) => pair.length !== 2
-  );
+  const existingParticipantIdPairs = [];
+  const genderMap = /* @__PURE__ */ new Map();
+  for (const participant of tournamentRecord.participants ?? []) {
+    const { participantType, participantId, person, individualParticipantIds } = participant;
+    if (participantType === INDIVIDUAL && person?.sex) {
+      genderMap.set(participantId, person.sex);
+    } else if (participantType === PAIR && individualParticipantIds) {
+      existingParticipantIdPairs.push(individualParticipantIds);
+    }
+  }
+  const invalidParticipantIdPairs = participantIdPairs.filter((pair) => {
+    if (pair.length !== 2)
+      return true;
+    if (!genderMap.has(pair[0]) || !genderMap.has(pair[1]))
+      return true;
+    if (!event.gender || event.gender === ANY)
+      return false;
+    const participantGenders = pair.map((id) => genderMap.get(id));
+    let invalidParticiapntGenders = event.gender === MALE && (participantGenders[0] !== MALE || participantGenders[1] !== MALE) || event.gender === FEMALE && (participantGenders[0] !== FEMALE || participantGenders[1] !== FEMALE);
+    if (event.gender === MIXED) {
+      participantGenders.sort();
+      if (participantGenders[0] !== FEMALE || participantGenders[1] !== MALE)
+        invalidParticiapntGenders = true;
+    }
+    return invalidParticiapntGenders;
+  });
   if (invalidParticipantIdPairs.length)
     return { error: INVALID_PARTICIPANT_IDS, invalidParticipantIdPairs };
-  const existingParticipantIdPairs = tournamentParticipants.filter((participant) => participant.participantType === PAIR).map((participant) => participant.individualParticipantIds);
   const provisionalParticipants = participantIdPairs.map(
-    (individualParticipantIds2) => ({
+    (individualParticipantIds) => ({
       participantId: uuids?.pop() ?? UUID(),
       participantRole: COMPETITOR,
-      individualParticipantIds: individualParticipantIds2,
+      individualParticipantIds,
       participantType: PAIR
     })
   );
@@ -59365,11 +59401,9 @@ function generateDrawDefinition(params) {
     ignoreAllowedDrawTypes,
     voluntaryConsolation,
     hydrateCollections,
-    policyDefinitions,
     ignoreStageSpace,
     tournamentRecord,
     qualifyingOnly,
-    seedingProfile,
     tieFormatName,
     drawEntries,
     addToEvent,
@@ -59380,8 +59414,19 @@ function generateDrawDefinition(params) {
     tournamentRecord,
     event
   }).appliedPolicies ?? {};
-  const drawTypeCoercion = params.drawTypeCoercion ?? appliedPolicies?.[POLICY_TYPE_DRAWS]?.drawTypeCoercion ?? true;
+  const policyDefinitions = params.policyDefinitions ?? {};
+  const drawTypeCoercion = params.drawTypeCoercion ?? policyDefinitions?.[POLICY_TYPE_DRAWS]?.drawTypeCoercion ?? appliedPolicies?.[POLICY_TYPE_DRAWS]?.drawTypeCoercion ?? true;
   const drawType = drawTypeCoercion && params.drawSize === 2 && DrawTypeEnum.SingleElimination || params.drawType || DrawTypeEnum.SingleElimination;
+  const seedingPolicy = policyDefinitions?.[POLICY_TYPE_SEEDING] ?? appliedPolicies?.[POLICY_TYPE_SEEDING];
+  const seedingProfile = params.seedingProfile ?? seedingPolicy?.seedingProfile?.drawTypes?.[drawType] ?? seedingPolicy?.seedingProfile;
+  if (params.seedingProfile) {
+    if (!policyDefinitions[POLICY_TYPE_SEEDING]) {
+      policyDefinitions[POLICY_TYPE_SEEDING] = {
+        ...POLICY_SEEDING_USTA[POLICY_TYPE_SEEDING]
+      };
+    }
+    policyDefinitions[POLICY_TYPE_SEEDING].seedingProfile = seedingProfile;
+  }
   const { participants, participantMap } = getParticipants$1({
     withIndividualParticipants: true,
     tournamentRecord
@@ -59514,7 +59559,7 @@ function generateDrawDefinition(params) {
       }
     }
   }
-  if (!appliedPolicies[POLICY_TYPE_SEEDING]) {
+  if (!appliedPolicies[POLICY_TYPE_SEEDING] && !policyDefinitions[POLICY_TYPE_SEEDING]) {
     attachPolicies({ drawDefinition, policyDefinitions: POLICY_SEEDING_USTA });
     Object.assign(appliedPolicies, POLICY_SEEDING_USTA);
   }
@@ -64002,8 +64047,8 @@ function generateFlight({
     const result2 = addEventEntries({
       participantIds: drawParticipantIds,
       autoEntryPositions,
+      entryStage: stage,
       tournamentRecord,
-      stage,
       event
     });
     if (result2.error)
@@ -64214,9 +64259,9 @@ function generateEventWithFlights(params) {
     if (eventParticipantIds.length) {
       const result = addEventEntries({
         participantIds: eventParticipantIds,
+        entryStage: StageTypeEnum.Main,
         autoEntryPositions,
         tournamentRecord,
-        stage: MAIN,
         event
       });
       if (result.error)
@@ -64455,7 +64500,7 @@ function generateEventWithDraw(params) {
           qualifyingIndex + participantsCount2
         );
         const result2 = addEventEntries({
-          entryStage: QUALIFYING,
+          entryStage: StageTypeEnum.Qualifying,
           entryStageSequence,
           autoEntryPositions,
           tournamentRecord,
@@ -65341,6 +65386,7 @@ const utilities = {
   categoryCanContain,
   chunkArray,
   compareTieFormats,
+  constantToString,
   countValues,
   createMap,
   dateRange,