tods-competition-factory 0.70.2 → 0.70.3

package/dist/tods-competition-factory.development.cjs.js

@@ -249,7 +249,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return '0.70.2';
+  return '0.70.3';
 }
 
 const FORMAT_STANDARD = 'SET3-S:6/TB7'; // Best of 3 Tiebreak Sets to 6
@@ -18389,20 +18389,30 @@ function getSeedBlocks({
   };
 }
 
+/**
+ * A seedBlock is an object pairing an array of drawPositions with an array of seedNumbers { drawPositions: [], seedNumbers: []}
+ * In an elimination structure The first seedBlock is { drawPositions: [1], seedNumbers: [1] }
+ * In an elimination structure The second seedBlock is{ drawPositions: [drawSize], seedNumbers: [2] }
+ * In an elimination structure the third seedBlock is { drawPositions: [a, b], seedNumbers: [3, 4] }
+ * In an elimination structure the fourth seedBlock is { drawPositions: [w, x, y, z], seedNumbers: [5, 6, 7, 8] }
+ * The calculations for the positioning of [a, b] and [w, x, y, z] are specific to seeding policies
+ */
+
 function getValidSeedBlocks({
-  drawDefinition,
   appliedPolicies,
+  drawDefinition,
   allPositions,
   structure
 }) {
   var _appliedPolicies$seed;
 
-  let firstRoundSeedsCount,
-      fedSeedNumberOffset = 0;
-  let error,
-      isFeedIn,
+  let fedSeedNumberOffset = 0,
+      firstRoundSeedsCount,
+      validSeedBlocks = [],
       isContainer,
-      validSeedBlocks = [];
+      isFeedIn,
+      isLucky,
+      error;
   if (!structure) return {
     error: MISSING_STRUCTURE
   };
@@ -18471,40 +18481,53 @@ function getValidSeedBlocks({
     // should be equal fo firstRoundDrawPositionOffset
 
     fedSeedNumberOffset = fedSeedBlockPositions.length;
+  } else if (firstRoundDrawPositions && !isPowerOf2(baseDrawSize)) {
+    // if there are first round draw positions it is not AdHoc
+    // if the baseDrawSize is not a power of 2 then it isLucky
+    firstRoundSeedsCount = 0;
+    isLucky = true;
   } else {
     firstRoundSeedsCount = countLimit;
   }
 
-  if (!isContainer) {
+  if (!isContainer && !isLucky) {
     const {
       blocks,
       error
     } = constructPower2Blocks({
-      baseDrawSize,
-      seedingProfile,
-      seedCountGoal: firstRoundSeedsCount,
+      drawPositionOffset: firstRoundDrawPositionOffset,
       seedNumberOffset: fedSeedNumberOffset,
-      drawPositionOffset: firstRoundDrawPositionOffset
+      seedCountGoal: firstRoundSeedsCount,
+      seedingProfile,
+      baseDrawSize
     });
 
     if (error) {
       return {
-        error,
         validSeedBlocks: [],
         isContainer,
-        isFeedIn
+        isFeedIn,
+        error
       };
     }
 
     blocks.forEach(block => validSeedBlocks.push(block));
   }
 
+  if (isLucky) {
+    const blocks = chunkArray(firstRoundDrawPositions, 2).map((block, i) => ({
+      drawPositions: [block[0]],
+      seedNumbers: [i + 1]
+    }));
+    blocks.forEach(block => validSeedBlocks.push(block));
+  }
+
   const seedDrawPositions = [].concat(...validSeedBlocks.map(seedBlock => seedBlock.drawPositions));
   const validSeedPositions = seedDrawPositions.reduce((result, drawPosition) => {
     return (firstRoundDrawPositions === null || firstRoundDrawPositions === void 0 ? void 0 : firstRoundDrawPositions.includes(drawPosition)) && result;
   }, true);
 
-  if (!isFeedIn && !isContainer && !validSeedPositions) {
+  if (!isLucky && !isFeedIn && !isContainer && !validSeedPositions) {
     return {
       error: INVALID_SEED_POSITION,
       validSeedBlocks: [],
@@ -18515,8 +18538,9 @@ function getValidSeedBlocks({
 
   return {
     validSeedBlocks,
+    isContainer,
     isFeedIn,
-    isContainer
+    isLucky
   };
 }
 
@@ -18620,11 +18644,11 @@ function constructContainerBlocks({
 }
 
 function constructPower2Blocks({
-  baseDrawSize,
-  seedCountGoal,
-  seedingProfile,
   drawPositionOffset = 0,
-  seedNumberOffset = 0
+  seedNumberOffset = 0,
+  seedingProfile,
+  seedCountGoal,
+  baseDrawSize
 }) {
   let count = 1;
   const blocks = [];
@@ -30531,14 +30555,15 @@ function getStructurePositionedSeeds({
 }
 
 function getSeedOrderByePositions({
-  structure,
-  drawDefinition,
+  relevantMatchUps,
   appliedPolicies,
-  relevantMatchUps
+  drawDefinition,
+  structure
 }) {
   const {
     validSeedBlocks,
     isFeedIn,
+    isLucky,
     isContainer
   } = getValidSeedBlocks({
     appliedPolicies,
@@ -30585,8 +30610,9 @@ function getSeedOrderByePositions({
   return {
     strictSeedOrderByePositions,
     blockSeedOrderByePositions,
+    isContainer,
     isFeedIn,
-    isContainer
+    isLucky
   };
 }
 
@@ -30611,9 +30637,10 @@ function getOrderedByePositions({
 }
 
 function getUnseededByePositions({
-  structure,
   appliedPolicies,
-  isFeedIn
+  structure,
+  isFeedIn,
+  isLucky
 }) {
   var _appliedPolicies$seed;
 
@@ -30702,9 +30729,9 @@ function getUnseededByePositions({
   const {
     validSeedBlocks
   } = getValidSeedBlocks({
-    structure,
+    allPositions: true,
     appliedPolicies,
-    allPositions: true
+    structure
   });
   const validBlockDrawPositions = validSeedBlocks.map(block => {
     var _block$drawPositions;
@@ -30855,14 +30882,15 @@ function positionByes({
     drawDefinition
   });
   const {
-    isFeedIn,
     strictSeedOrderByePositions,
-    blockSeedOrderByePositions
+    blockSeedOrderByePositions,
+    isFeedIn,
+    isLucky
   } = getSeedOrderByePositions({
-    structure,
-    drawDefinition,
+    relevantMatchUps,
     appliedPolicies,
-    relevantMatchUps
+    drawDefinition,
+    structure
   });
   const seedOrderByePositions = blockOrdered ? blockSeedOrderByePositions : strictSeedOrderByePositions;
   const {
@@ -30870,9 +30898,10 @@ function positionByes({
   } = getUnseededByePositions({
     appliedPolicies,
     structure,
-    isFeedIn
+    isFeedIn,
+    isLucky
   }); // first add all drawPositions paired with sorted seeds drawPositions
-  // then add quarter separated dnd evenly distributed drawPositions
+  // then add quarter separated and evenly distributed drawPositions
   // derived from theoretical seeding of firstRoundParticipants/2
 
   const byePositions = [].concat(...seedOrderByePositions, ...(seedsOnly ? [] : unseededByePositions)); // then take only the number of required byes
@@ -31087,6 +31116,7 @@ function automatedPositioning$1({
   structureId,
   matchUpsMap,
   seedsOnly,
+  drawType,
   event
 }) {
   const {
@@ -31148,15 +31178,18 @@ function automatedPositioning$1({
   } else {
     // otherwise... seeds need to be placed first so that BYEs
     // can follow the seedValues of placed seeds
-    let result = positionSeedBlocks({
-      inContextDrawMatchUps,
-      drawDefinition,
-      participants,
-      matchUpsMap,
-      structure
-    });
-    if (result.error) return result;
-    result = positionByes({
+    if (drawType !== LUCKY_DRAW) {
+      let result = positionSeedBlocks({
+        inContextDrawMatchUps,
+        drawDefinition,
+        participants,
+        matchUpsMap,
+        structure
+      });
+      if (result.error) return result;
+    }
+
+    const result = positionByes({
       inContextDrawMatchUps,
       drawDefinition,
       matchUpsMap,
@@ -31171,12 +31204,12 @@ function automatedPositioning$1({
 
   if (!seedsOnly) {
     let result = positionUnseededParticipants({
+      inContextDrawMatchUps,
       candidatesCount,
       drawDefinition,
       participants,
-      structure,
       matchUpsMap,
-      inContextDrawMatchUps
+      structure
     });
     if (result.error) return result;
     if (result.conflicts) conflicts.unseededConflicts = result.conflicts;
@@ -44748,7 +44781,9 @@ function generateDrawDefinition(params) {
     seedsCount,
     event
   });
-  if (seedLimit && seedLimit < seedsCount) seedsCount = seedLimit;
+  if (seedLimit && seedLimit < seedsCount) seedsCount = seedLimit; // temporary until seeding is supported in LUCKY_DRAW
+
+  if (drawType === LUCKY_DRAW) seedsCount = 0;
 
   if (seededParticipants) {
     seededParticipants.filter(({
@@ -44843,7 +44878,9 @@ function generateDrawDefinition(params) {
       participants,
       structureId,
       matchUpsMap,
-      seedsOnly
+      seedsOnly,
+      drawType,
+      event
     }));
   }
 
@@ -51353,7 +51390,7 @@ function getParticipantsCount({
     }
   });
 
-  if (drawProfiles) {
+  if (Array.isArray(drawProfiles)) {
     for (const drawProfile of drawProfiles) {
       processDrawProfile(drawProfile);
     }
@@ -52636,6 +52673,9 @@ function generateTournamentRecord({
   if (startDate && !isValidDateString(startDate) || endDate && !isValidDateString(endDate)) return {
     error: INVALID_DATE
   };
+  if (eventProfiles && !Array.isArray(eventProfiles)) return {
+    error: INVALID_VALUES
+  };
 
   if (!startDate) {
     const tournamentDate = new Date();
@@ -52687,7 +52727,7 @@ function generateTournamentRecord({
         eventIds = [],
         allUniqueParticipantIds = [];
 
-  if (drawProfiles) {
+  if (Array.isArray(drawProfiles)) {
     let drawIndex = 0;
 
     for (const drawProfile of drawProfiles) {