tods-competition-factory 1.6.19 → 1.6.21

package/dist/forge/generate.mjs

@@ -3002,15 +3002,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,
@@ -4208,31 +4208,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 = {
@@ -4267,14 +4264,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];
@@ -4508,8 +4501,8 @@ function getAllStructureMatchUps({
       matchUpsMap,
       structureId
     }).drawPositionsRanges : void 0;
-    matchUps = matchUps.map(
-      (matchUp) => addMatchUpContext({
+    matchUps = matchUps.map((matchUp) => {
+      return addMatchUpContext({
         scheduleVisibilityFilters,
         sourceDrawPositionRanges,
         drawPositionsRanges,
@@ -4520,8 +4513,8 @@ function getAllStructureMatchUps({
         roundProfile,
         matchUp,
         event
-      })
-    );
+      });
+    });
     const matchUpTies = matchUps?.filter(
       (matchUp) => Array.isArray(matchUp.tieMatchUps)
     );
@@ -5296,7 +5289,7 @@ function getValidSeedBlocks({
   let validSeedBlocks = [];
   if (!structure)
     return { error: MISSING_STRUCTURE };
-  const { roundMatchUps } = getAllStructureMatchUps({
+  const { matchUps, roundMatchUps } = getAllStructureMatchUps({
     matchUpFilters: { roundNumbers: [1] },
     provisionalPositioning,
     structure
@@ -5329,12 +5322,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
@@ -5370,14 +5367,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,
@@ -5396,7 +5393,7 @@ function getValidSeedBlocks({
     },
     true
   );
-  if (!isLucky && !isFeedIn && !isContainer && !validSeedPositions) {
+  if (!isLuckyStructure && !isFeedIn && !isContainer && !validSeedPositions) {
     return {
       error: INVALID_SEED_POSITION,
       validSeedBlocks: [],
@@ -5405,10 +5402,10 @@ function getValidSeedBlocks({
     };
   }
   return {
+    isLuckyStructure,
     validSeedBlocks,
     isContainer,
-    isFeedIn,
-    isLucky
+    isFeedIn
   };
 }
 function getContainerBlocks({ seedingProfile, structure }) {
@@ -11431,6 +11428,113 @@ function consolationCleanup({
   return { ...SUCCESS };
 }
 
+function removeLineUpSubstitutions({ lineUp }) {
+  if (!Array.isArray(lineUp))
+    return;
+  const participantAssignments = {};
+  const permutations = unique(
+    lineUp.flatMap(
+      ({ collectionAssignments }) => collectionAssignments.map(
+        ({ collectionId, collectionPosition }) => [collectionId, collectionPosition].join("|")
+      )
+    )
+  );
+  permutations.forEach((permutation) => {
+    const [collectionId, position] = permutation.split("|");
+    const collectionPosition = parseInt(position);
+    const { assignedParticipantIds } = getCollectionPositionAssignments({
+      collectionPosition,
+      collectionId,
+      lineUp
+    });
+    assignedParticipantIds.forEach((participantId) => {
+      if (!participantAssignments[participantId])
+        participantAssignments[participantId] = [];
+      participantAssignments[participantId].push({
+        collectionId,
+        collectionPosition
+      });
+    });
+  });
+  return Object.keys(participantAssignments).map((participantId) => ({
+    participantId,
+    collectionAssignments: participantAssignments[participantId]
+  }));
+}
+
+function mustBeAnArray(value) {
+  return `${value} must be an array`;
+}
+
+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({ element: drawDefinition, extension });
+  addDrawNotice({ drawDefinition });
+  return { ...SUCCESS };
+}
+
 function resetLineUps({
   inContextDrawMatchUps,
   inheritance = true,
@@ -11458,10 +11562,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,
@@ -12243,7 +12355,7 @@ function getSeedOrderByePositions({
       structure
     });
   }
-  const { isFeedIn, isLucky, isContainer } = seedBlockInfo;
+  const { isFeedIn, isLuckyStructure, isContainer } = seedBlockInfo;
   let { validSeedBlocks } = seedBlockInfo;
   if (appliedPolicies?.seeding?.containerByesIgnoreSeeding)
     validSeedBlocks = [];
@@ -12287,10 +12399,10 @@ function getSeedOrderByePositions({
   return {
     strictSeedOrderByePositions,
     blockSeedOrderByePositions,
+    isLuckyStructure,
     positionedSeeds,
     isContainer,
-    isFeedIn,
-    isLucky
+    isFeedIn
   };
 }
 function getOrderedByePositions({
@@ -12317,12 +12429,12 @@ function getOrderedByePositions({
 function getUnseededByePositions({
   provisionalPositioning,
   seedOrderByePositions,
+  isLuckyStructure,
   appliedPolicies,
   drawDefinition,
   seedLimit,
   structure,
-  isFeedIn,
-  isLucky
+  isFeedIn
 }) {
   const seedingProfile = appliedPolicies?.seeding?.seedingProfile;
   const isQualifying = structure.stage === QUALIFYING;
@@ -12540,8 +12652,8 @@ function positionByes({
   const {
     strictSeedOrderByePositions,
     blockSeedOrderByePositions,
-    isFeedIn,
-    isLucky
+    isLuckyStructure,
+    isFeedIn
   } = getSeedOrderByePositions({
     provisionalPositioning,
     relevantMatchUps,
@@ -12556,12 +12668,12 @@ function positionByes({
   let { unseededByePositions } = getUnseededByePositions({
     provisionalPositioning,
     seedOrderByePositions,
+    isLuckyStructure,
     appliedPolicies,
     drawDefinition,
     seedLimit,
     structure,
-    isFeedIn,
-    isLucky
+    isFeedIn
   });
   const isOdd = (x) => x % 2;
   const isNotPaired = (arr, c) => (arr || []).every((a) => isOdd(a) ? c !== a + 1 : c !== a - 1);
@@ -16008,10 +16120,6 @@ function drawPositionsAssignedParticipantIds({ structure, matchUp }) {
   return assignedParticipantIds?.length === 2;
 }
 
-function mustBeAnArray(value) {
-  return `${value} must be an array`;
-}
-
 function stringify(matchUpFormatObject, preserveRedundant) {
   if (typeof matchUpFormatObject !== "object")
     return;
@@ -16701,40 +16809,6 @@ function updateTieMatchUpScore({
   };
 }
 
-function removeLineUpSubstitutions({ lineUp }) {
-  if (!Array.isArray(lineUp))
-    return;
-  const participantAssignments = {};
-  const permutations = unique(
-    lineUp.flatMap(
-      ({ collectionAssignments }) => collectionAssignments.map(
-        ({ collectionId, collectionPosition }) => [collectionId, collectionPosition].join("|")
-      )
-    )
-  );
-  permutations.forEach((permutation) => {
-    const [collectionId, position] = permutation.split("|");
-    const collectionPosition = parseInt(position);
-    const { assignedParticipantIds } = getCollectionPositionAssignments({
-      collectionPosition,
-      collectionId,
-      lineUp
-    });
-    assignedParticipantIds.forEach((participantId) => {
-      if (!participantAssignments[participantId])
-        participantAssignments[participantId] = [];
-      participantAssignments[participantId].push({
-        collectionId,
-        collectionPosition
-      });
-    });
-  });
-  return Object.keys(participantAssignments).map((participantId) => ({
-    participantId,
-    collectionAssignments: participantAssignments[participantId]
-  }));
-}
-
 function directWinner({
   winnerMatchUpDrawPositionIndex,
   inContextDrawMatchUps,