tods-competition-factory 1.8.18 → 1.8.20

package/dist/forge/generate.mjs

@@ -9454,8 +9454,8 @@ function updateInContextMatchUp({ tournamentId, inContextMatchUp }) {
     return { error: MISSING_MATCHUP };
   }
   addNotice({
-    topic: UPDATE_INCONTEXT_MATCHUP,
     payload: { inContextMatchUp, tournamentId },
+    topic: UPDATE_INCONTEXT_MATCHUP,
     key: inContextMatchUp.matchUpId
   });
   return { ...SUCCESS };
@@ -10654,8 +10654,8 @@ function updateSideLineUp({
     element: drawDefinition,
     name: LINEUPS
   });
-  const value = existingExtension?.value || {};
-  const lineUp = value[teamParticipantId];
+  const lineUps = existingExtension?.value || {};
+  const lineUp = makeDeepCopy(lineUps[teamParticipantId], false, true);
   if (sideExists) {
     matchUp?.sides?.forEach((side) => {
       if (side.sideNumber === drawPositionSideNumber) {
@@ -10670,13 +10670,12 @@ function updateSideLineUp({
     const targetSide = matchUp.sides.find(
       (side) => side.sideNumber === drawPositionSideNumber
     );
-    if (targetSide) {
+    if (targetSide)
       targetSide.lineUp = lineUp;
-    }
   }
   modifyMatchUpNotice({
     tournamentId: tournamentRecord?.tournamentId,
-    context: "updateSidLineUps",
+    context: "updateSidLineUp",
     eventId: event?.eventId,
     drawDefinition,
     matchUp
@@ -11493,10 +11492,10 @@ function removeLineUpSubstitutions({ lineUp }) {
   const participantAssignments = {};
   const permutations = unique(
     lineUp.flatMap(
-      ({ collectionAssignments }) => collectionAssignments.map(
+      ({ collectionAssignments }) => collectionAssignments?.map(
         ({ collectionId, collectionPosition }) => [collectionId, collectionPosition].join("|")
       )
-    )
+    ).filter(Boolean)
   );
   permutations.forEach((permutation) => {
     const [collectionId, position] = permutation.split("|");
@@ -15973,7 +15972,7 @@ const toBePlayed = {
   winningSide: void 0
 };
 
-function findMatchUp({
+function findDrawMatchUp({
   tournamentParticipants,
   afterRecoveryTimes,
   contextContent,
@@ -16035,7 +16034,7 @@ function modifyMatchUpScore({
   const isDualMatchUp = matchUp.matchUpType === TEAM$2;
   if (isDualMatchUp && drawDefinition) {
     if (matchUpId && matchUp.matchUpId !== matchUpId) {
-      const findResult = findMatchUp({
+      const findResult = findDrawMatchUp({
         drawDefinition,
         matchUpId,
         event
@@ -16064,7 +16063,7 @@ function modifyMatchUpScore({
   if (removeWinningSide)
     matchUp.winningSide = void 0;
   if (!structure && drawDefinition) {
-    ({ structure } = findMatchUp({
+    ({ structure } = findDrawMatchUp({
       drawDefinition,
       matchUpId,
       event
@@ -16219,6 +16218,48 @@ function drawPositionsAssignedParticipantIds({ structure, matchUp }) {
   return assignedParticipantIds?.length === 2;
 }
 
+function ensureSideLineUps({
+  inContextDualMatchUp,
+  drawDefinition,
+  tournamentId,
+  dualMatchUp,
+  eventId
+}) {
+  if (dualMatchUp && !dualMatchUp?.sides?.length) {
+    if (!inContextDualMatchUp) {
+      inContextDualMatchUp = findDrawMatchUp({
+        matchUpId: dualMatchUp.matchUpId,
+        inContext: true,
+        drawDefinition
+      })?.matchUp;
+    }
+    const { extension } = findExtension$1({
+      element: drawDefinition,
+      name: LINEUPS
+    });
+    const lineUps = makeDeepCopy(extension?.value || {}, false, true);
+    const extractSideDetail = ({
+      displaySideNumber,
+      drawPosition,
+      sideNumber
+    }) => ({ drawPosition, sideNumber, displaySideNumber });
+    dualMatchUp.sides = inContextDualMatchUp?.sides?.map((side) => {
+      const participantId = side.participantId;
+      return {
+        ...extractSideDetail(side),
+        lineUp: participantId && lineUps[participantId] || []
+      };
+    });
+    modifyMatchUpNotice({
+      context: "ensureSidLineUps",
+      matchUp: dualMatchUp,
+      drawDefinition,
+      tournamentId,
+      eventId
+    });
+  }
+}
+
 const typeMatch = (arr, type) => arr.filter(Boolean).every((i) => typeof i === type);
 const allNumeric = (arr) => arr.filter(Boolean).every(isNumeric);
 function getCategoryAgeDetails(params) {
@@ -16390,28 +16431,53 @@ function getCategoryAgeDetails(params) {
   return result;
 }
 
+function validateCategory({ category }) {
+  if (!isObject(category))
+    return { error: INVALID_VALUES };
+  const categoryDetails = getCategoryAgeDetails({ category });
+  if (categoryDetails.error)
+    return { error: categoryDetails };
+  const { ratingMax, ratingMin } = category;
+  if (ratingMax && !isNumeric(ratingMax))
+    return decorateResult({
+      result: { error: INVALID_VALUES },
+      context: { ratingMax }
+    });
+  if (ratingMin && !isNumeric(ratingMin))
+    return decorateResult({
+      result: { error: INVALID_VALUES },
+      context: { ratingMin }
+    });
+  return { ...categoryDetails };
+}
+
 function categoryCanContain({
   childCategory,
   withDetails,
   category
 }) {
-  const categoryDetails = getCategoryAgeDetails({ category });
-  const childCategoryDetails = getCategoryAgeDetails({
+  const categoryDetails = validateCategory({ category });
+  const childCategoryDetails = validateCategory({
     category: childCategory
   });
   const invalidAgeMin = childCategoryDetails.ageMin && (categoryDetails.ageMin && childCategoryDetails.ageMin < categoryDetails.ageMin || categoryDetails.ageMax && childCategoryDetails.ageMin > categoryDetails.ageMax);
   const invalidAgeMax = childCategoryDetails.ageMax && (categoryDetails.ageMax && childCategoryDetails.ageMax > categoryDetails.ageMax || categoryDetails.ageMin && childCategoryDetails.ageMax < categoryDetails.ageMin);
   const invalidAgeMinDate = childCategoryDetails.ageMinDate && categoryDetails.ageMaxDate && new Date(childCategoryDetails.ageMinDate) > new Date(categoryDetails.ageMaxDate);
   const invalidAgeMaxDate = childCategoryDetails.ageMaxDate && categoryDetails.ageMinDate && new Date(childCategoryDetails.ageMaxDate) < new Date(categoryDetails.ageMinDate);
-  const valid = !invalidAgeMax && !invalidAgeMin && !invalidAgeMinDate && !invalidAgeMaxDate;
+  const ratingComparison = category.ratingType && childCategory.ratingType && category.ratingType === childCategory.ratingType;
+  const invalidRatingRange = ratingComparison && (category.ratingMin && childCategory.ratingMin && childCategory.ratingMin < category.ratingMin || category.ratingMax && childCategory.ratingMax && childCategory.ratingMax > category.ratingMax || category.ratingMin && childCategory.ratingMax && childCategory.ratingMax < category.ratingMin || category.ratingMax && childCategory.ratingMin && childCategory.ratingMin > category.ratingMax);
+  const invalidBallType = category.ballType && childCategory.ballType && category.ballType !== childCategory.ballType;
+  const valid = !invalidRatingRange && !invalidAgeMinDate && !invalidAgeMaxDate && !invalidBallType && !invalidAgeMax && !invalidAgeMin;
   const ignoreFalse = true;
   const result = definedAttributes(
     {
-      valid,
+      invalidRatingRange,
+      invalidAgeMinDate,
+      invalidAgeMaxDate,
+      invalidBallType,
       invalidAgeMax,
       invalidAgeMin,
-      invalidAgeMinDate,
-      invalidAgeMaxDate
+      valid
     },
     ignoreFalse
   );
@@ -16686,8 +16752,8 @@ function validateCollectionDefinition({
   if (checkGender && referenceGender && gender && [GenderEnum.Male, GenderEnum.Female].includes(referenceGender) && referenceGender !== gender) {
     errors.push(`Invalid gender: ${gender}`);
     return decorateResult({
+      result: { error: INVALID_GENDER, errors },
       context: { referenceGender, gender },
-      result: { error: INVALID_GENDER },
       stack
     });
   }
@@ -17007,7 +17073,7 @@ function generateTieMatchUpScore(params) {
     }
     if (!winningSide && tallyDirectives) {
       const matchUpId = matchUp.matchUpId;
-      const inContextMatchUp = matchUp.hasContext ? matchUp : matchUpsMap?.drawMatchUps?.[matchUpId] || drawDefinition && findMatchUp({
+      const inContextMatchUp = matchUp.hasContext ? matchUp : matchUpsMap?.drawMatchUps?.[matchUpId] || drawDefinition && findDrawMatchUp({
         inContext: true,
         drawDefinition,
         matchUpId
@@ -17051,7 +17117,7 @@ function updateTieMatchUpScore({
   matchUpId,
   event
 }) {
-  const result = findMatchUp({ drawDefinition, event, matchUpId });
+  const result = findDrawMatchUp({ drawDefinition, event, matchUpId });
   if (result.error)
     return result;
   if (!result.matchUp)
@@ -17059,6 +17125,12 @@ function updateTieMatchUpScore({
   const { matchUp, structure } = result;
   if (!matchUp.tieMatchUps)
     return { error: INVALID_MATCHUP };
+  ensureSideLineUps({
+    tournamentId: tournamentRecord?.tournamentId,
+    eventId: event?.eventId,
+    dualMatchUp: matchUp,
+    drawDefinition
+  });
   const { extension } = findExtension({
     name: DISABLE_AUTO_CALC,
     element: matchUp
@@ -21040,7 +21112,7 @@ function setMatchUpFormat(params) {
     return { error: UNRECOGNIZED_MATCHUP_FORMAT };
   const stack = "setMatchUpFormat";
   if (matchUpId) {
-    const result = findMatchUp({
+    const result = findDrawMatchUp({
       drawDefinition,
       matchUpId,
       event
@@ -21325,25 +21397,65 @@ function isUngrouped(entryStatus) {
   return [UNPAIRED, UNGROUPED].includes(entryStatus);
 }
 
+const POLICY_MATCHUP_ACTIONS_DEFAULT = {
+  [POLICY_TYPE_MATCHUP_ACTIONS]: {
+    policyName: "matchUpActionsDefault",
+    // matchUpActions will be selectively enabled for structures matching { stages: [], stageSequences: [] }
+    // enabledStructures: [] => all structures are enabled
+    enabledStructures: [
+      {
+        stages: [],
+        // stages: [] => applies to all stages
+        stageSequences: [],
+        // stageSequences: [] => applies to all stageSequences
+        enabledActions: [],
+        disabledActions: []
+        // disabledActions: [] => no actions are disabled
+      }
+    ],
+    participants: {
+      enforceCategory: true,
+      // validate collectionDefinition.category against event.category
+      enforceGender: true
+      // disallow placing FEMALEs in MALE events and vice versa
+    },
+    processCodes: {
+      substitution: ["RANKING.IGNORE", "RATING.IGNORE"]
+    },
+    substituteAfterCompleted: false,
+    substituteWithoutScore: false
+  }
+};
+
 function checkValidEntries({
-  enforceGender = true,
   consideredEntries,
+  policyDefinitions,
   tournamentRecord,
+  appliedPolicies,
+  participantMap,
+  enforceGender,
   participants,
   event
 }) {
-  participants = participants || tournamentRecord?.participants;
+  if ((!participants || !participantMap) && tournamentRecord) {
+    ({ participants, participantMap } = getParticipants({
+      tournamentRecord
+    }));
+  }
   if (!participants)
     return { error: MISSING_PARTICIPANTS };
   if (!Array.isArray(participants))
     return { error: INVALID_VALUES };
   if (!event)
     return { error: MISSING_EVENT };
+  const matchUpActionsPolicy = policyDefinitions?.[POLICY_TYPE_MATCHUP_ACTIONS] ?? appliedPolicies?.[POLICY_TYPE_MATCHUP_ACTIONS] ?? POLICY_MATCHUP_ACTIONS_DEFAULT[POLICY_TYPE_MATCHUP_ACTIONS];
+  const genderEnforced = (enforceGender ?? matchUpActionsPolicy?.participants?.enforceGender) !== false;
   const { eventType, gender: eventGender } = event;
-  const participantType = eventType === TEAM_EVENT && TEAM || eventType === DOUBLES_EVENT && PAIR || INDIVIDUAL;
+  const isDoubles = eventType === DOUBLES_EVENT;
+  const participantType = eventType === TEAM_EVENT && TEAM || isDoubles && PAIR || INDIVIDUAL;
   const entryStatusMap = Object.assign(
     {},
-    ...(consideredEntries || event.entries || []).map((entry) => ({
+    ...(consideredEntries ?? event.entries ?? []).map((entry) => ({
       [entry.participantId]: entry.entryStatus
     }))
   );
@@ -21355,9 +21467,14 @@ function checkValidEntries({
     const entryStatus = entryStatusMap[participant.participantId];
     const ungroupedParticipant = eventType && [TypeEnum.Doubles, TypeEnum.Team].includes(eventType) && participant.participantType === INDIVIDUAL && (isUngrouped(entryStatus) || entryStatus === WITHDRAWN);
     const mismatch = participant.participantType !== participantType && !ungroupedParticipant;
+    const pairGender = !mismatch && isDoubles && unique(
+      participant?.individualParticipantIds?.map((id) => participantMap?.[id]?.participant?.person?.sex).filter(Boolean) ?? []
+    );
+    const validPairGender = !eventGender || !pairGender?.length || GenderEnum.Any === eventGender || [GenderEnum.Male, GenderEnum.Female].includes(eventGender) && pairGender[0] === eventGender || GenderEnum.Mixed === eventGender && (pairGender.length == 1 && participant.individualParticipantIds?.length === 1 || pairGender.length === 2);
     const personGender = participant?.person?.sex;
-    const wrongGender = enforceGender && eventGender && eventType === TypeEnum.Singles && [GenderEnum.Male, GenderEnum.Female].includes(eventGender) && personGender !== eventGender;
-    return mismatch || wrongGender;
+    const validPersonGender = !participant?.person || !eventGender || [GenderEnum.Any, GenderEnum.Mixed].includes(eventGender) || [GenderEnum.Male, GenderEnum.Female].includes(eventGender) && personGender === eventGender;
+    const validGender = !genderEnforced || validPairGender && validPersonGender;
+    return mismatch || !validGender;
   });
   if (invalidEntries.length) {
     const invalidParticipantIds = invalidEntries.map(
@@ -21365,7 +21482,7 @@ function checkValidEntries({
     );
     return { error: INVALID_ENTRIES, invalidParticipantIds };
   }
-  return { ...SUCCESS };
+  return { ...SUCCESS, valid: true };
 }
 
 function getValidStage({ stage, drawDefinition }) {
@@ -23249,7 +23366,7 @@ function generateDrawDefinition(params) {
   }).appliedPolicies ?? {};
   const drawTypeCoercion = params.drawTypeCoercion ?? appliedPolicies?.[POLICY_TYPE_DRAWS]?.drawTypeCoercion ?? true;
   const drawType = drawTypeCoercion && params.drawSize === 2 && DrawTypeEnum.SingleElimination || params.drawType || DrawTypeEnum.SingleElimination;
-  const { participants } = getParticipants({
+  const { participants, participantMap } = getParticipants({
     withIndividualParticipants: true,
     tournamentRecord
   });
@@ -23268,6 +23385,8 @@ function generateDrawDefinition(params) {
   const consideredEntries = (qualifyingOnly && [] || drawEntries || (considerEventEntries ? eventEntries : [])).filter(({ entryStage }) => !entryStage || entryStage === MAIN);
   const validEntriesResult = event && participants && checkValidEntries({
     consideredEntries,
+    appliedPolicies,
+    participantMap,
     enforceGender,
     participants,
     event