tods-competition-factory 1.6.19 → 1.6.21

package/dist/forge/transform.mjs

@@ -3617,6 +3617,7 @@ function getInContextCourt({
   return { inContextCourt };
 }
 
+const ADD_DRAW_DEFINITION = "addDrawDefinition";
 const ADD_VENUE = "addVenue";
 const MODIFY_DRAW_DEFINITION = "modifyDrawDefinition";
 const MODIFY_MATCHUP = "modifyMatchUp";
@@ -4470,15 +4471,15 @@ function getRoundMatchUps({
       roundIndex += 1;
     }
   });
-  const isNotEliminationStructure = !!Object.values(roundProfile).find(
+  const roundsNotPowerOf2 = !!Object.values(roundProfile).find(
     ({ matchUpsCount }) => !isPowerOf2(matchUpsCount)
   );
   const hasNoRoundPositions = matchUps.some(
     (matchUp) => !matchUp.roundPosition
   );
   return {
-    isNotEliminationStructure,
     hasNoRoundPositions,
+    roundsNotPowerOf2,
     maxMatchUpsCount,
     roundMatchUps,
     roundNumbers,
@@ -5505,31 +5506,28 @@ function filterMatchUps(params) {
 }
 
 function isLucky({
-  isNotEliminationStructure,
+  roundsNotPowerOf2,
   drawDefinition,
-  roundMatchUps,
-  structure
+  structure,
+  matchUps
 }) {
   if (!structure)
     return false;
-  if (!roundMatchUps) {
-    ({ isNotEliminationStructure, roundMatchUps } = getRoundMatchUps({
-      matchUps: structure.matchUps ?? []
-    }));
-  }
-  const hasFirstRoundDrawPositions = !!roundMatchUps?.[1]?.find(
-    ({ drawPositions }) => drawPositions
-  );
-  const noSecondRoundDrawPositions = !roundMatchUps?.[2]?.find(
-    ({ drawPositions }) => drawPositions
-  );
-  return isNotEliminationStructure && !structure?.structures && hasFirstRoundDrawPositions && noSecondRoundDrawPositions && !(drawDefinition?.drawType && drawDefinition.drawType !== LUCKY_DRAW);
+  matchUps = matchUps ?? structure.matchUps ?? [];
+  roundsNotPowerOf2 = roundsNotPowerOf2 ?? getRoundMatchUps({ matchUps }).roundsNotPowerOf2;
+  const hasDrawPositions = !!structure.positionAssignments?.find(({ drawPosition }) => drawPosition) || !!matchUps?.find(({ drawPositions }) => drawPositions?.length);
+  return (!drawDefinition?.drawType || drawDefinition.drawType !== LUCKY_DRAW) && !structure?.structures && roundsNotPowerOf2 && hasDrawPositions;
 }
 
 function isAdHoc({ drawDefinition, structure }) {
   if (!structure)
     return false;
-  return !structure?.structures && !(drawDefinition?.drawType && drawDefinition.drawType !== AD_HOC) && !structure?.matchUps?.find(({ roundPosition }) => !!roundPosition);
+  const matchUps = structure.matchUps || structure.roundMatchUps && Object.values(structure.roundMatchUps).flat();
+  const hasRoundPosition = matchUps?.find((matchUp) => matchUp?.roundPosition);
+  const hasDrawPosition = matchUps?.find(
+    (matchUp) => matchUp?.drawPositions?.length
+  );
+  return !structure?.structures && !(drawDefinition?.drawType && drawDefinition.drawType !== AD_HOC) && !hasRoundPosition && !hasDrawPosition;
 }
 
 const POLICY_ROUND_NAMING_DEFAULT = {
@@ -5564,14 +5562,10 @@ function getRoundContextProfile({
   structure,
   matchUps
 }) {
-  const { isNotEliminationStructure, roundProfile, roundMatchUps } = getRoundMatchUps({ matchUps });
+  const { roundProfile, roundMatchUps } = getRoundMatchUps({ matchUps });
   const { structureAbbreviation, stage } = structure;
   const isAdHocStructure = isAdHoc({ structure });
-  const isLuckyStructure = isLucky({
-    isNotEliminationStructure,
-    roundMatchUps,
-    structure
-  });
+  const isLuckyStructure = isLucky({ structure });
   const isRoundRobin = structure.structures;
   const roundNamingProfile = {};
   const defaultRoundNamingPolicy = POLICY_ROUND_NAMING_DEFAULT[POLICY_TYPE_ROUND_NAMING];
@@ -5805,8 +5799,8 @@ function getAllStructureMatchUps({
       matchUpsMap,
       structureId
     }).drawPositionsRanges : void 0;
-    matchUps = matchUps.map(
-      (matchUp) => addMatchUpContext({
+    matchUps = matchUps.map((matchUp) => {
+      return addMatchUpContext({
         scheduleVisibilityFilters,
         sourceDrawPositionRanges,
         drawPositionsRanges,
@@ -5817,8 +5811,8 @@ function getAllStructureMatchUps({
         roundProfile,
         matchUp,
         event
-      })
-    );
+      });
+    });
     const matchUpTies = matchUps?.filter(
       (matchUp) => Array.isArray(matchUp.tieMatchUps)
     );
@@ -7480,6 +7474,23 @@ function updateInContextMatchUp({ tournamentId, inContextMatchUp }) {
   });
   return { ...SUCCESS };
 }
+function addDrawNotice({
+  tournamentId,
+  eventId,
+  drawDefinition
+}) {
+  if (!drawDefinition) {
+    console.log(MISSING_DRAW_DEFINITION);
+    return { error: MISSING_DRAW_DEFINITION };
+  }
+  drawUpdatedAt(drawDefinition);
+  addNotice({
+    payload: { drawDefinition, tournamentId, eventId },
+    topic: ADD_DRAW_DEFINITION,
+    key: drawDefinition.drawId
+  });
+  return { ...SUCCESS };
+}
 function modifyDrawNotice({
   drawDefinition,
   tournamentId,
@@ -13097,7 +13108,7 @@ function getValidSeedBlocks({
   let validSeedBlocks = [];
   if (!structure)
     return { error: MISSING_STRUCTURE };
-  const { roundMatchUps } = getAllStructureMatchUps({
+  const { matchUps, roundMatchUps } = getAllStructureMatchUps({
     matchUpFilters: { roundNumbers: [1] },
     provisionalPositioning,
     structure
@@ -13130,12 +13141,16 @@ function getValidSeedBlocks({
   const { stage, structureType, roundLimit } = structure;
   const isContainer = structureType === CONTAINER;
   const isFeedIn = !isContainer && uniqueDrawPositionsByRound?.length;
-  const isLucky = firstRoundDrawPositions?.length && !isPowerOf2(baseDrawSize);
   const qualifyingBlocks = !isContainer && stage === QUALIFYING && roundLimit;
   const fedSeedBlockPositions = seedRangeDrawPositionBlocks.flat(Infinity);
   const fedSeedNumberOffset = isFeedIn ? fedSeedBlockPositions?.length : 0;
   const countLimit = allPositions ? positionsCount : seedsCount;
-  const firstRoundSeedsCount = isLucky ? 0 : !isFeedIn && countLimit || countLimit && fedSeedBlockPositions.length < countLimit && countLimit - fedSeedBlockPositions.length || 0;
+  const isLuckyStructure = isLucky({
+    drawDefinition,
+    structure,
+    matchUps
+  });
+  const firstRoundSeedsCount = isLuckyStructure ? 0 : !isFeedIn && countLimit || countLimit && fedSeedBlockPositions.length < countLimit && countLimit - fedSeedBlockPositions.length || 0;
   if (qualifyingBlocks) {
     const seedingBlocksCount = structure?.matchUps ? structure.matchUps.filter(
       ({ roundNumber }) => roundNumber === structure.roundLimit
@@ -13171,14 +13186,14 @@ function getValidSeedBlocks({
     validSeedBlocks = seedRangeDrawPositionBlocks.map((block) => {
       return { seedNumbers: block, drawPositions: block };
     });
-  } else if (isLucky) {
+  } else if (isLuckyStructure) {
     const blocks = chunkArray(firstRoundDrawPositions, 2).map((block, i) => ({
       drawPositions: [block[0]],
       seedNumbers: [i + 1]
     }));
     blocks.forEach((block) => validSeedBlocks.push(block));
   }
-  if (!isContainer && !isLucky && !qualifyingBlocks) {
+  if (!isContainer && !isLuckyStructure && !qualifyingBlocks) {
     const { blocks } = constructPower2Blocks({
       drawPositionOffset: firstRoundDrawPositionOffset,
       seedNumberOffset: fedSeedNumberOffset,
@@ -13197,7 +13212,7 @@ function getValidSeedBlocks({
     },
     true
   );
-  if (!isLucky && !isFeedIn && !isContainer && !validSeedPositions) {
+  if (!isLuckyStructure && !isFeedIn && !isContainer && !validSeedPositions) {
     return {
       error: INVALID_SEED_POSITION,
       validSeedBlocks: [],
@@ -13206,10 +13221,10 @@ function getValidSeedBlocks({
     };
   }
   return {
+    isLuckyStructure,
     validSeedBlocks,
     isContainer,
-    isFeedIn,
-    isLucky
+    isFeedIn
   };
 }
 function getContainerBlocks({ seedingProfile, structure }) {
@@ -13453,6 +13468,75 @@ function getTargetMatchUps({
   return { drawPositions, matchUps, targetMatchUps };
 }
 
+function validateLineUp({ lineUp, tieFormat }) {
+  const errors = [];
+  if (!Array.isArray(lineUp)) {
+    errors.push(mustBeAnArray("lineUp"));
+    return { valid: false, errors, error: INVALID_VALUES };
+  }
+  const validItems = lineUp.every((item) => {
+    if (typeof item !== "object") {
+      errors.push(`lineUp entries must be objects`);
+      return false;
+    }
+    const { participantId, collectionAssignments } = item;
+    if (!participantId) {
+      errors.push("Missing participantId");
+      return false;
+    }
+    if (typeof participantId !== "string") {
+      errors.push("participantIds must be strings");
+      return false;
+    }
+    if (!Array.isArray(collectionAssignments)) {
+      errors.push(mustBeAnArray("collectionAssignments"));
+      return false;
+    }
+    return collectionAssignments.every((collectionAssignment) => {
+      if (typeof collectionAssignment !== "object") {
+        errors.push("collectionAssignments must be objects");
+        return false;
+      }
+      const { collectionPosition } = collectionAssignment;
+      if (typeof collectionPosition !== "number") {
+        errors.push("collectionPosition must be a number");
+        return false;
+      }
+      return true;
+    });
+  });
+  const noDuplicates = unique(lineUp.map(getParticipantId)).length === lineUp.length;
+  if (!noDuplicates)
+    errors.push("Duplicated participantId(s)");
+  const valid = validItems && noDuplicates;
+  return { valid, errors, error: errors.length ? INVALID_VALUES : void 0 };
+}
+
+function updateTeamLineUp({
+  drawDefinition,
+  participantId,
+  tieFormat,
+  lineUp
+}) {
+  if (typeof drawDefinition !== "object")
+    return { error: MISSING_DRAW_DEFINITION };
+  if (typeof participantId !== "string")
+    return { error: MISSING_PARTICIPANT_ID };
+  const validation = validateLineUp({ lineUp, tieFormat });
+  if (!validation.valid)
+    return validation;
+  const { extension: existingExtension } = findExtension({
+    element: drawDefinition,
+    name: LINEUPS
+  });
+  const value = existingExtension?.value || {};
+  value[participantId] = removeLineUpSubstitutions({ lineUp });
+  const extension = { name: LINEUPS, value };
+  addExtension$1({ element: drawDefinition, extension });
+  addDrawNotice({ drawDefinition });
+  return { ...SUCCESS };
+}
+
 function resetLineUps({
   inContextDrawMatchUps,
   inheritance = true,
@@ -13480,10 +13564,18 @@ function resetLineUps({
           ({ matchUpId }) => matchUpId === inContextMatchUp.matchUpId
         );
         if (matchUp?.sides?.[sideIndex]) {
-          if (inheritance) {
-            delete matchUp.sides[sideIndex].lineUp;
-          } else {
-            matchUp.sides[sideIndex].lineUp = [];
+          delete matchUp.sides[sideIndex].lineUp;
+          if (inheritance === false) {
+            const tieFormat = inContextMatchUp.tieFormat;
+            const participantId = side.participantId;
+            if (tieFormat && participantId) {
+              updateTeamLineUp({
+                drawDefinition,
+                participantId,
+                lineUp: [],
+                tieFormat
+              });
+            }
           }
           modifyMatchUpNotice({
             tournamentId: tournamentRecord?.tournamentId,