tods-competition-factory 0.70.2 → 0.72.1

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

@@ -249,7 +249,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return '0.70.2';
+  return '0.72.1';
 }
 
 const FORMAT_STANDARD = 'SET3-S:6/TB7'; // Best of 3 Tiebreak Sets to 6
@@ -11560,6 +11560,8 @@ function getAllStructureMatchUps({
 
     if (tournamentParticipants && matchUpWithContext.sides) {
       matchUpWithContext.sides.filter(Boolean).forEach(side => {
+        var _side$participant;
+
         if (side.participantId) {
           const participant = findParticipant({
             policyDefinitions: appliedPolicies,
@@ -11574,7 +11576,7 @@ function getAllStructureMatchUps({
           }
         }
 
-        if (side.participant && side.participant.individualParticipantIds) {
+        if (side !== null && side !== void 0 && (_side$participant = side.participant) !== null && _side$participant !== void 0 && _side$participant.individualParticipantIds) {
           const individualParticipants = side.participant.individualParticipantIds.map(participantId => {
             return findParticipant({
               policyDefinitions: appliedPolicies,
@@ -16878,14 +16880,6 @@ function getPairedPreviousMatchUpIsWOWO(params) {
     roundNumber,
     roundPosition
   }) => roundNumber === previousRoundNumber && roundPosition === pairedRoundPosition);
-  /*
-  const { pairedPreviousMatchUp } = getPairedPreviousMatchUp({
-    matchUp: sourceMatchUp,
-    structureId: structure.structureId,
-    matchUpsMap,
-  });
-  */
-
   const pairedPreviousMatchUpStatus = pairedPreviousMatchUp === null || pairedPreviousMatchUp === void 0 ? void 0 : pairedPreviousMatchUp.matchUpStatus;
   const pairedPreviousMatchUpisWOWO = [DOUBLE_WALKOVER].includes(pairedPreviousMatchUpStatus);
   return {
@@ -17439,12 +17433,12 @@ function getWalkoverWinningSide({
 }
 
 function assignMatchUpDrawPosition({
+  inContextDrawMatchUps,
   drawDefinition,
-  matchUpId,
   matchUpStatus,
   drawPosition,
   matchUpsMap,
-  inContextDrawMatchUps
+  matchUpId
 }) {
   var _drawDefinition$struc, _matchUpsMap, _matchUpsMap$drawMatc;
 
@@ -17519,10 +17513,10 @@ function assignMatchUpDrawPosition({
   }
 
   const targetData = positionTargets({
-    matchUpId,
-    drawDefinition,
     inContextDrawMatchUps,
-    inContextMatchUp
+    inContextMatchUp,
+    drawDefinition,
+    matchUpId
   });
   const {
     targetMatchUps: {
@@ -17543,12 +17537,12 @@ function assignMatchUpDrawPosition({
     if (winnerMatchUp) {
       if ([BYE, DOUBLE_WALKOVER].includes(matchUpStatus)) {
         const result = assignMatchUpDrawPosition({
-          drawDefinition,
-          drawPosition,
           matchUpId: winnerMatchUp.matchUpId,
           iterative: 'brightmagenta',
-          matchUpsMap,
-          inContextDrawMatchUps
+          inContextDrawMatchUps,
+          drawDefinition,
+          drawPosition,
+          matchUpsMap
         });
         if (result.error) return result;
       } else {
@@ -17561,24 +17555,24 @@ function assignMatchUpDrawPosition({
         }
       }
     }
-  } else {
+  } else if (winnerMatchUp && !inContextMatchUp.feedRound) {
     const {
       pairedPreviousMatchUpisWOWO
     } = getPairedPreviousMatchUpIsWOWO({
       winnerMatchUp: matchUp,
       drawPosition,
-      structure,
-      matchUpsMap
+      matchUpsMap,
+      structure
     });
 
-    if (pairedPreviousMatchUpisWOWO && winnerMatchUp) {
+    if (pairedPreviousMatchUpisWOWO) {
       const result = assignMatchUpDrawPosition({
-        drawDefinition,
-        drawPosition,
         matchUpId: winnerMatchUp.matchUpId,
         iterative: 'brightred',
-        matchUpsMap,
-        inContextDrawMatchUps
+        inContextDrawMatchUps,
+        drawDefinition,
+        drawPosition,
+        matchUpsMap
       });
       if (result.error) return result;
     }
@@ -18389,20 +18383,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 +18475,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 +18532,9 @@ function getValidSeedBlocks({
 
   return {
     validSeedBlocks,
+    isContainer,
     isFeedIn,
-    isContainer
+    isLucky
   };
 }
 
@@ -18620,11 +18638,11 @@ function constructContainerBlocks({
 }
 
 function constructPower2Blocks({
-  baseDrawSize,
-  seedCountGoal,
-  seedingProfile,
   drawPositionOffset = 0,
-  seedNumberOffset = 0
+  seedNumberOffset = 0,
+  seedingProfile,
+  seedCountGoal,
+  baseDrawSize
 }) {
   let count = 1;
   const blocks = [];
@@ -19557,9 +19575,9 @@ function attemptToSetWinningSide(params) {
 }
 
 function getPairedPreviousMatchUp({
-  matchUp,
   structureId,
-  matchUpsMap
+  matchUpsMap,
+  matchUp
 }) {
   const sourceRoundPosition = matchUp === null || matchUp === void 0 ? void 0 : matchUp.roundPosition;
   const offset = sourceRoundPosition % 2 ? 1 : -1;
@@ -19579,12 +19597,12 @@ function getPairedPreviousMatchUp({
 
 function removeDoubleWalkover(params) {
   const {
+    inContextDrawMatchUps,
     drawDefinition,
+    matchUpsMap,
     targetData,
     structure,
-    matchUp,
-    matchUpsMap,
-    inContextDrawMatchUps
+    matchUp
   } = params;
   const {
     targetLinks: {
@@ -19610,29 +19628,40 @@ function removeDoubleWalkover(params) {
 
 
   if (winnerMatchUp) {
-    var _pairedPreviousMatchU;
-
-    const noContextWinnerMatchUp = matchUpsMap === null || matchUpsMap === void 0 ? void 0 : matchUpsMap.drawMatchUps.find(matchUp => matchUp.matchUpId === winnerMatchUp.matchUpId);
-    const {
-      pairedPreviousMatchUp
-    } = getPairedPreviousMatchUp({
-      matchUp,
-      structureId: structure.structureId,
-      matchUpsMap
-    });
-    const pairedPreviousWOWO = (pairedPreviousMatchUp === null || pairedPreviousMatchUp === void 0 ? void 0 : pairedPreviousMatchUp.matchUpStatus) === DOUBLE_WALKOVER;
-    const pairedPreviousDrawPositions = (pairedPreviousMatchUp === null || pairedPreviousMatchUp === void 0 ? void 0 : (_pairedPreviousMatchU = pairedPreviousMatchUp.drawPositions) === null || _pairedPreviousMatchU === void 0 ? void 0 : _pairedPreviousMatchU.filter(Boolean)) || [];
-    const pairedPreviousMatchUpComplete = [...completedMatchUpStatuses, BYE].includes(pairedPreviousMatchUp === null || pairedPreviousMatchUp === void 0 ? void 0 : pairedPreviousMatchUp.matchUpStatus) || (pairedPreviousMatchUp === null || pairedPreviousMatchUp === void 0 ? void 0 : pairedPreviousMatchUp.winningSide);
     const nextTargetData = positionTargets({
       matchUpId: winnerMatchUp.matchUpId,
-      drawDefinition,
-      inContextDrawMatchUps
+      inContextDrawMatchUps,
+      drawDefinition
     });
     const {
       targetMatchUps: {
         winnerMatchUp: nextWinnerMatchUp
       }
     } = nextTargetData;
+    const noContextWinnerMatchUp = matchUpsMap === null || matchUpsMap === void 0 ? void 0 : matchUpsMap.drawMatchUps.find(matchUp => matchUp.matchUpId === winnerMatchUp.matchUpId);
+    let pairedPreviousDrawPositions = [];
+    let pairedPreviousMatchUpComplete;
+    let pairedPreviousWOWO; // winnerMatchUp has context
+
+    if (winnerMatchUp.feedRound) {
+      var _nextWinnerMatchUp$dr;
+
+      pairedPreviousDrawPositions = nextWinnerMatchUp === null || nextWinnerMatchUp === void 0 ? void 0 : (_nextWinnerMatchUp$dr = nextWinnerMatchUp.drawPositions) === null || _nextWinnerMatchUp$dr === void 0 ? void 0 : _nextWinnerMatchUp$dr.filter(Boolean);
+      pairedPreviousMatchUpComplete = true;
+    } else {
+      var _pairedPreviousMatchU;
+
+      const {
+        pairedPreviousMatchUp
+      } = getPairedPreviousMatchUp({
+        structureId: structure.structureId,
+        matchUpsMap,
+        matchUp
+      });
+      pairedPreviousWOWO = (pairedPreviousMatchUp === null || pairedPreviousMatchUp === void 0 ? void 0 : pairedPreviousMatchUp.matchUpStatus) === DOUBLE_WALKOVER;
+      pairedPreviousDrawPositions = (pairedPreviousMatchUp === null || pairedPreviousMatchUp === void 0 ? void 0 : (_pairedPreviousMatchU = pairedPreviousMatchUp.drawPositions) === null || _pairedPreviousMatchU === void 0 ? void 0 : _pairedPreviousMatchU.filter(Boolean)) || [];
+      pairedPreviousMatchUpComplete = [...completedMatchUpStatuses, BYE].includes(pairedPreviousMatchUp === null || pairedPreviousMatchUp === void 0 ? void 0 : pairedPreviousMatchUp.matchUpStatus) || (pairedPreviousMatchUp === null || pairedPreviousMatchUp === void 0 ? void 0 : pairedPreviousMatchUp.winningSide);
+    }
 
     if (pairedPreviousMatchUpComplete) {
       const sourceDrawPositions = matchUp.drawPositions || [];
@@ -19647,23 +19676,23 @@ function removeDoubleWalkover(params) {
 
       if (nextWinnerMatchUp && drawPositionToRemove) {
         const result = removeDirectedWinner({
+          winningDrawPosition: drawPositionToRemove,
           winnerMatchUp: nextWinnerMatchUp,
+          inContextDrawMatchUps,
           drawDefinition,
-          winningDrawPosition: drawPositionToRemove,
-          matchUpsMap,
-          inContextDrawMatchUps
+          matchUpsMap
         });
         if (result.error) return result;
       }
     }
 
     removeDoubleWalkover({
-      drawDefinition,
       targetData: nextTargetData,
-      structure,
       matchUp: winnerMatchUp,
+      inContextDrawMatchUps,
+      drawDefinition,
       matchUpsMap,
-      inContextDrawMatchUps
+      structure
     });
     let matchUpStatus = [WALKOVER$1, DOUBLE_WALKOVER].includes(noContextWinnerMatchUp === null || noContextWinnerMatchUp === void 0 ? void 0 : noContextWinnerMatchUp.matchUpStatus) && pairedPreviousWOWO ? WALKOVER$1 : TO_BE_PLAYED;
     const removeScore = !pairedPreviousWOWO;
@@ -20428,17 +20457,17 @@ function setMatchUpStatus$1(params) {
   }
 
   return setMatchUpStatus$2({
-    tournamentRecord,
-    drawDefinition,
-    event,
     matchUpStatusCodes: outcome === null || outcome === void 0 ? void 0 : outcome.matchUpStatusCodes,
     matchUpStatus: outcome === null || outcome === void 0 ? void 0 : outcome.matchUpStatus,
-    matchUpFormat,
-    matchUpId,
     winningSide: outcome === null || outcome === void 0 ? void 0 : outcome.winningSide,
     allowChangePropagation,
     score: outcome === null || outcome === void 0 ? void 0 : outcome.score,
+    tournamentRecord,
+    drawDefinition,
+    matchUpFormat,
+    matchUpId,
     schedule,
+    event,
     notes
   });
 }
@@ -22292,7 +22321,7 @@ function addParticipantContext(params) {
       var _participant$individu;
 
       const groupParticipantId = participant.participantId;
-      (_participant$individu = participant.individualParticipantIds) === null || _participant$individu === void 0 ? void 0 : _participant$individu.forEach(participantId => {
+      participant === null || participant === void 0 ? void 0 : (_participant$individu = participant.individualParticipantIds) === null || _participant$individu === void 0 ? void 0 : _participant$individu.forEach(participantId => {
         if (!participantIdMap[participantId].groupParticipantIds.includes(groupParticipantId)) {
           participantIdMap[participantId].groupParticipantIds.push(groupParticipantId);
           participantIdMap[participantId].groups.push({
@@ -22309,7 +22338,7 @@ function addParticipantContext(params) {
       var _participant$individu2;
 
       const teamParticipantId = participant.participantId;
-      (_participant$individu2 = participant.individualParticipantIds) === null || _participant$individu2 === void 0 ? void 0 : _participant$individu2.forEach(participantId => {
+      participant === null || participant === void 0 ? void 0 : (_participant$individu2 = participant.individualParticipantIds) === null || _participant$individu2 === void 0 ? void 0 : _participant$individu2.forEach(participantId => {
         if (!participantIdMap[participantId].teamParticipantIds.includes(teamParticipantId)) {
           participantIdMap[participantId].teamParticipantIds.push(teamParticipantId);
           participantIdMap[participantId].teams.push({
@@ -22327,7 +22356,7 @@ function addParticipantContext(params) {
       var _participant$individu3;
 
       const pairParticipantId = participant.participantId;
-      (_participant$individu3 = participant.individualParticipantIds) === null || _participant$individu3 === void 0 ? void 0 : _participant$individu3.forEach(participantId => {
+      participant === null || participant === void 0 ? void 0 : (_participant$individu3 = participant.individualParticipantIds) === null || _participant$individu3 === void 0 ? void 0 : _participant$individu3.forEach(participantId => {
         if (!participantIdMap[participantId].pairParticipantIds.includes(pairParticipantId)) {
           participantIdMap[participantId].pairParticipantIds.push(pairParticipantId);
         }
@@ -30531,14 +30560,15 @@ function getStructurePositionedSeeds({
 }
 
 function getSeedOrderByePositions({
-  structure,
-  drawDefinition,
+  relevantMatchUps,
   appliedPolicies,
-  relevantMatchUps
+  drawDefinition,
+  structure
 }) {
   const {
     validSeedBlocks,
     isFeedIn,
+    isLucky,
     isContainer
   } = getValidSeedBlocks({
     appliedPolicies,
@@ -30585,8 +30615,9 @@ function getSeedOrderByePositions({
   return {
     strictSeedOrderByePositions,
     blockSeedOrderByePositions,
+    isContainer,
     isFeedIn,
-    isContainer
+    isLucky
   };
 }
 
@@ -30599,7 +30630,7 @@ function getOrderedByePositions({
   // In CONTAINER/ROUND_ROBIN structures drawPositions are duplicated
   // and therefore must placed in drawOrder within Groups
   const matchUpDrawPositionPairs = relevantMatchUps.map(matchUp => matchUp.drawPositions);
-  const consideredDrawPositionPairs = matchUpDrawPositionPairs.map(pair => pair.sort((a, b) => a - b)).filter(pair => pair[0] + 1 === pair[1]); // sort seededMatchUps so that pairedPositions represent seed order
+  const consideredDrawPositionPairs = matchUpDrawPositionPairs.map(pair => pair === null || pair === void 0 ? void 0 : pair.sort((a, b) => a - b)).filter(pair => (pair === null || pair === void 0 ? void 0 : pair[0]) + 1 === (pair === null || pair === void 0 ? void 0 : pair[1])); // sort seededMatchUps so that pairedPositions represent seed order
 
   const seedOrderSortedDrawPositionPairs = orderedSeedDrawPositions.map(drawPosition => consideredDrawPositionPairs.find(drawPositions => drawPositions === null || drawPositions === void 0 ? void 0 : drawPositions.includes(drawPosition))).filter(Boolean);
   const orderedByePositions = seedOrderSortedDrawPositionPairs.map(drawPositions => {
@@ -30611,9 +30642,10 @@ function getOrderedByePositions({
 }
 
 function getUnseededByePositions({
-  structure,
   appliedPolicies,
-  isFeedIn
+  structure,
+  isFeedIn,
+  isLucky
 }) {
   var _appliedPolicies$seed;
 
@@ -30702,9 +30734,9 @@ function getUnseededByePositions({
   const {
     validSeedBlocks
   } = getValidSeedBlocks({
-    structure,
+    allPositions: true,
     appliedPolicies,
-    allPositions: true
+    structure
   });
   const validBlockDrawPositions = validSeedBlocks.map(block => {
     var _block$drawPositions;
@@ -30728,7 +30760,7 @@ function getUnseededByePositions({
   } // for Round Robins pairs need to be reduced to pairs in drawPosition order
 
 
-  const matchUpPairedDrawPositions = relevantMatchUps.map(matchUp => matchUp.drawPositions).map(pair => pair.sort((a, b) => a - b)).filter(pair => pair[0] + 1 === pair[1]);
+  const matchUpPairedDrawPositions = relevantMatchUps.map(matchUp => matchUp.drawPositions).map(pair => pair === null || pair === void 0 ? void 0 : pair.sort((a, b) => a - b)).filter(pair => (pair === null || pair === void 0 ? void 0 : pair[0]) + 1 === (pair === null || pair === void 0 ? void 0 : pair[1]));
 
   const findDrawPositionPair = drawPosition => {
     return matchUpPairedDrawPositions.reduce((pair, candidate) => {
@@ -30855,14 +30887,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 +30903,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 +31121,7 @@ function automatedPositioning$1({
   structureId,
   matchUpsMap,
   seedsOnly,
+  drawType,
   event
 }) {
   const {
@@ -31148,15 +31183,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 +31209,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;
@@ -36000,14 +36038,14 @@ function addEventEntries(params) {
   var _tournamentRecord$par;
 
   const {
+    entryStatus = DIRECT_ACCEPTANCE,
+    autoEntryPositions = true,
+    participantIds = [],
+    entryStage = MAIN,
     tournamentRecord,
     drawDefinition,
     drawId,
-    event,
-    participantIds = [],
-    entryStatus = DIRECT_ACCEPTANCE,
-    entryStage = MAIN,
-    autoEntryPositions = true
+    event
   } = params;
   if (!event) return {
     error: MISSING_EVENT
@@ -36035,7 +36073,7 @@ function addEventEntries(params) {
       return true;
     }
 
-    if (event.eventType === TEAM$1 && participant.participantType === TEAM$1) {
+    if (event.eventType === TEAM$1 && (participant.participantType === TEAM$1 || entryStatus === UNGROUPED && participant.participantType === INDIVIDUAL$1)) {
       return true;
     }
 
@@ -36055,7 +36093,7 @@ function addEventEntries(params) {
   });
   let message;
 
-  if (drawId) {
+  if (drawId && !isUngrouped(entryStage)) {
     const result = addDrawEntries({
       participantIds: validParticipantIds,
       autoEntryPositions,
@@ -36948,7 +36986,7 @@ function generateDrawMaticRound({
   if (teamParticipants) {
     // add SAME_TEAM_VALUE for participants who appear on the same team
     for (const teamParticipant of teamParticipants) {
-      const participantIds = teamParticipant.individualParticipantIds;
+      const participantIds = teamParticipant.individualParticipantIds || [];
       const {
         uniquePairings
       } = getPairingsData({
@@ -40498,6 +40536,44 @@ function addPersons({
   };
 }
 
+/**
+ * function called internally to cleanup event entries when individuals have been added to team events
+ */
+
+function updateTeamEventEntries({
+  individualParticipantIds,
+  groupingParticipantId,
+  tournamentRecord
+}) {
+  const relevantEvents = (tournamentRecord.events || []).filter(event => {
+    var _event$entries;
+
+    return (event === null || event === void 0 ? void 0 : event.eventType) === TEAM$2 && (event === null || event === void 0 ? void 0 : (_event$entries = event.entries) === null || _event$entries === void 0 ? void 0 : _event$entries.some(entry => entry.participantId === groupingParticipantId));
+  });
+
+  const filterEntry = entry => !individualParticipantIds.includes(entry.participantId);
+
+  for (const event of relevantEvents) {
+    var _flightProfile$flight, _event$drawDefinition;
+
+    event.entries = (event.entries || []).filter(filterEntry);
+    const {
+      flightProfile
+    } = getFlightProfile({
+      event
+    });
+    flightProfile === null || flightProfile === void 0 ? void 0 : (_flightProfile$flight = flightProfile.flights) === null || _flightProfile$flight === void 0 ? void 0 : _flightProfile$flight.forEach(flight => {
+      flight.drawEntries = (flight.drawEntries || []).filter(filterEntry);
+    });
+    event === null || event === void 0 ? void 0 : (_event$drawDefinition = event.drawDefinitions) === null || _event$drawDefinition === void 0 ? void 0 : _event$drawDefinition.forEach(drawDefinition => {
+      drawDefinition.entries = (drawDefinition.entries || []).filter(filterEntry);
+    });
+  }
+
+  return { ...SUCCESS
+  };
+}
+
 /**
  *
  * @param {object} tournamentRecord - passed in automatically by tournamentEngine
@@ -40508,10 +40584,10 @@ function addPersons({
  */
 
 function addIndividualParticipantIds({
-  tournamentRecord,
-  groupingParticipantId,
   individualParticipantIds,
-  removeFromOtherTeams
+  groupingParticipantId,
+  removeFromOtherTeams,
+  tournamentRecord
 }) {
   if (!tournamentRecord) return {
     error: MISSING_TOURNAMENT_RECORD
@@ -40575,9 +40651,15 @@ function addIndividualParticipantIds({
     });
   }
 
-  return { ...SUCCESS,
+  updateTeamEventEntries({
+    individualParticipantIds,
+    groupingParticipantId,
+    tournamentRecord
+  });
+  return {
     groupingParticipant: makeDeepCopy(groupingParticipant),
-    added: participantIdsToAdd.length
+    added: participantIdsToAdd.length,
+    ...SUCCESS
   };
 }
 
@@ -44748,7 +44830,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 +44927,9 @@ function generateDrawDefinition(params) {
       participants,
       structureId,
       matchUpsMap,
-      seedsOnly
+      seedsOnly,
+      drawType,
+      event
     }));
   }
 
@@ -50667,6 +50753,7 @@ function completeDrawMatchUps({
   };
 }
 function completeDrawMatchUp({
+  matchUpStatusCodes,
   drawDefinition,
   targetMatchUp,
   matchUpStatus,
@@ -50688,6 +50775,7 @@ function completeDrawMatchUp({
     scoreString,
     winningSide
   });
+  if (matchUpStatusCodes) outcome.matchUpStatusCodes = matchUpStatusCodes;
   return setMatchUpStatus$1({
     drawDefinition,
     matchUpFormat,
@@ -51353,7 +51441,7 @@ function getParticipantsCount({
     }
   });
 
-  if (drawProfiles) {
+  if (Array.isArray(drawProfiles)) {
     for (const drawProfile of drawProfiles) {
       processDrawProfile(drawProfile);
     }
@@ -52106,6 +52194,7 @@ function generateEventWithDraw({
             matchUpFormat,
             stageSequence = 1,
             matchUpStatus = COMPLETED,
+            matchUpStatusCodes,
             matchUpIndex = 0,
             structureOrder // like a group number; for RR = the order of the structureType: ITEM within structureType: CONTAINER
 
@@ -52133,6 +52222,7 @@ function generateEventWithDraw({
 
           const targetMatchUp = targetMatchUps[matchUpIndex];
           const result = completeDrawMatchUp({
+            matchUpStatusCodes,
             drawDefinition,
             targetMatchUp,
             matchUpFormat,
@@ -52636,6 +52726,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 +52780,7 @@ function generateTournamentRecord({
         eventIds = [],
         allUniqueParticipantIds = [];
 
-  if (drawProfiles) {
+  if (Array.isArray(drawProfiles)) {
     let drawIndex = 0;
 
     for (const drawProfile of drawProfiles) {