tods-competition-factory 1.6.19 → 1.6.21

package/dist/forge/query.d.ts

@@ -2035,7 +2035,7 @@ type GetRoundMatchUpsArgs = {
     interpolate?: boolean;
 };
 type RoundMatchUpsResult = {
-    isNotEliminationStructure?: boolean;
+    roundsNotPowerOf2?: boolean;
     roundMatchUps?: HydratedMatchUp[];
     hasNoRoundPositions?: boolean;
     roundProfile?: RoundProfile;

package/dist/forge/query.mjs

@@ -4015,15 +4015,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,
@@ -6722,31 +6722,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 = {
@@ -6781,14 +6778,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];
@@ -7023,8 +7016,8 @@ function getAllStructureMatchUps({
       matchUpsMap,
       structureId
     }).drawPositionsRanges : void 0;
-    matchUps = matchUps.map(
-      (matchUp) => addMatchUpContext({
+    matchUps = matchUps.map((matchUp) => {
+      return addMatchUpContext({
         scheduleVisibilityFilters,
         sourceDrawPositionRanges,
         drawPositionsRanges,
@@ -7035,8 +7028,8 @@ function getAllStructureMatchUps({
         roundProfile,
         matchUp,
         event
-      })
-    );
+      });
+    });
     const matchUpTies = matchUps?.filter(
       (matchUp) => Array.isArray(matchUp.tieMatchUps)
     );
@@ -11483,7 +11476,7 @@ function getValidSeedBlocks({
   let validSeedBlocks = [];
   if (!structure)
     return { error: MISSING_STRUCTURE };
-  const { roundMatchUps } = getAllStructureMatchUps({
+  const { matchUps, roundMatchUps } = getAllStructureMatchUps({
     matchUpFilters: { roundNumbers: [1] },
     provisionalPositioning,
     structure
@@ -11516,12 +11509,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
@@ -11557,14 +11554,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,
@@ -11583,7 +11580,7 @@ function getValidSeedBlocks({
     },
     true
   );
-  if (!isLucky && !isFeedIn && !isContainer && !validSeedPositions) {
+  if (!isLuckyStructure && !isFeedIn && !isContainer && !validSeedPositions) {
     return {
       error: INVALID_SEED_POSITION,
       validSeedBlocks: [],
@@ -11592,10 +11589,10 @@ function getValidSeedBlocks({
     };
   }
   return {
+    isLuckyStructure,
     validSeedBlocks,
     isContainer,
-    isFeedIn,
-    isLucky
+    isFeedIn
   };
 }
 function getContainerBlocks({ seedingProfile, structure }) {