tods-competition-factory 0.68.0 → 0.69.2

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

@@ -249,7 +249,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return '0.68.0';
+  return '0.69.2';
 }
 
 const FORMAT_STANDARD = 'SET3-S:6/TB7'; // Best of 3 Tiebreak Sets to 6
@@ -7325,12 +7325,14 @@ var collectionDefinitions = [
 	}
 ];
 var tieFormatName = "Doubles Shuffle";
+var unrestrictedSelections = true;
 var winCriteria = {
 	aggregateValue: true
 };
 var TEAM_AGGREGATION_TIE_FORMAT = {
 	collectionDefinitions: collectionDefinitions,
 	tieFormatName: tieFormatName,
+	unrestrictedSelections: unrestrictedSelections,
 	winCriteria: winCriteria
 };
 
@@ -7401,6 +7403,7 @@ const SINGLE_ELIMINATION = 'SINGLE_ELIMINATION';
 const DOUBLE_ELIMINATION = 'DOUBLE_ELIMINATION';
 const FIRST_MATCH_LOSER_CONSOLATION = 'FIRST_MATCH_LOSER_CONSOLATION';
 const FIRST_ROUND_LOSER_CONSOLATION = 'FIRST_ROUND_LOSER_CONSOLATION';
+const LUCKY_DRAW = 'LUCKY_DRAW';
 const CURTIS = 'CURTIS_CONSOLATION';
 const FICSF = 'FEED_IN_CHAMPIONSHIP_TO_SF';
 const FEED_IN_CHAMPIONSHIP_TO_SF = 'FEED_IN_CHAMPIONSHIP_TO_SF';
@@ -7471,8 +7474,8 @@ const OLYMPIC_ATTRIBUTES = {
 
 const WIN_RATIO = 'WIN_RATIO';
 const ROUND_OUTCOME = 'ROUND_OUTCOME';
-const MULTI_STRUCTURE_DRAWS = [FEED_IN$1, COMPASS, PLAY_OFF, OLYMPIC, CURTIS, FICSF, FICQF, FICR16, FIRST_MATCH_LOSER_CONSOLATION, FIRST_ROUND_LOSER_CONSOLATION, MODIFIED_FEED_IN_CHAMPIONSHIP, FEED_IN_CHAMPIONSHIP_TO_R16, FEED_IN_CHAMPIONSHIP_TO_QF, FEED_IN_CHAMPIONSHIP_TO_SF, FEED_IN_CHAMPIONSHIP, ROUND_ROBIN_WITH_PLAYOFF];
-const generatedDrawTypes = [AD_HOC, COMPASS, CURTIS, DOUBLE_ELIMINATION, FEED_IN_CHAMPIONSHIP_TO_QF, FEED_IN_CHAMPIONSHIP_TO_R16, FEED_IN_CHAMPIONSHIP_TO_SF, FEED_IN_CHAMPIONSHIP, FEED_IN$1, FIRST_MATCH_LOSER_CONSOLATION, FIRST_ROUND_LOSER_CONSOLATION, MODIFIED_FEED_IN_CHAMPIONSHIP, OLYMPIC, PLAY_OFF, ROUND_ROBIN, ROUND_ROBIN_WITH_PLAYOFF, SINGLE_ELIMINATION];
+const MULTI_STRUCTURE_DRAWS = [COMPASS, CURTIS, FEED_IN_CHAMPIONSHIP_TO_QF, FEED_IN_CHAMPIONSHIP_TO_R16, FEED_IN_CHAMPIONSHIP_TO_SF, FEED_IN_CHAMPIONSHIP, FICQF, FICR16, FICSF, FIRST_MATCH_LOSER_CONSOLATION, FIRST_ROUND_LOSER_CONSOLATION, LUCKY_DRAW, MODIFIED_FEED_IN_CHAMPIONSHIP, OLYMPIC, PLAY_OFF, ROUND_ROBIN_WITH_PLAYOFF];
+const generatedDrawTypes = [AD_HOC, COMPASS, CURTIS, DOUBLE_ELIMINATION, FEED_IN_CHAMPIONSHIP_TO_QF, FEED_IN_CHAMPIONSHIP_TO_R16, FEED_IN_CHAMPIONSHIP_TO_SF, FEED_IN_CHAMPIONSHIP, FEED_IN$1, FIRST_MATCH_LOSER_CONSOLATION, FIRST_ROUND_LOSER_CONSOLATION, LUCKY_DRAW, MODIFIED_FEED_IN_CHAMPIONSHIP, OLYMPIC, PLAY_OFF, ROUND_ROBIN, ROUND_ROBIN_WITH_PLAYOFF, SINGLE_ELIMINATION];
 const drawDefinitionConstants = {
   MAIN,
   QUALIFYING,
@@ -7516,7 +7519,8 @@ const drawDefinitionConstants = {
   WIN_RATIO,
   ROUND_OUTCOME,
   MULTI_STRUCTURE_DRAWS,
-  generatedDrawTypes
+  generatedDrawTypes,
+  stageOrder
 };
 
 const WITHDRAW_PARTICIPANT_METHOD = 'withdrawParticipantAtDrawPosition';
@@ -9325,11 +9329,11 @@ function getTeamLineUp({
 
 const extractor = object => attr => object[attr];
 
-const getMatchUpIds = (o = []) => o.map(getMatchUpId$1).filter(Boolean);
+const getMatchUpIds = (o = []) => o.map(getMatchUpId).filter(Boolean);
 const getParticipantIds = (o = []) => o.map(getParticipantId).filter(Boolean);
 const getParticipantId = (o = {}) => extractor(o)('participantId');
 const getDrawPosition = (o = {}) => extractor(o)('drawPosition');
-const getMatchUpId$1 = (o = {}) => extractor(o)('matchUpId');
+const getMatchUpId = (o = {}) => extractor(o)('matchUpId');
 
 function getDrawPositionCollectionAssignment({
   tournamentParticipants,
@@ -9609,6 +9613,7 @@ function getMappedStructureMatchUps({
 
     if (inContext) {
       return matchUps.map(matchUp => Object.assign(makeDeepCopy(matchUp, true, true), {
+        containerStructureId: structureId,
         structureId: itemStructureId,
         structureName
       }));
@@ -10685,6 +10690,31 @@ function getOrderedDrawPositions({
   };
 }
 
+function isLucky({
+  drawDefinition,
+  structure
+}) {
+  var _roundMatchUps$, _roundMatchUps$2;
+
+  if (!structure) return false;
+  const {
+    roundProfile,
+    roundMatchUps
+  } = getRoundMatchUps$1({
+    matchUps: structure.matchUps || []
+  });
+  const hasFirstRoundDrawPositions = !!(roundMatchUps !== null && roundMatchUps !== void 0 && (_roundMatchUps$ = roundMatchUps[1]) !== null && _roundMatchUps$ !== void 0 && _roundMatchUps$.find(({
+    drawPositions
+  }) => drawPositions));
+  const noSecondRoundDrawPositions = !(roundMatchUps !== null && roundMatchUps !== void 0 && (_roundMatchUps$2 = roundMatchUps[2]) !== null && _roundMatchUps$2 !== void 0 && _roundMatchUps$2.find(({
+    drawPositions
+  }) => drawPositions));
+  const hasOddMatchUpsCount = Object.values(roundProfile).find(({
+    matchUpsCount
+  }) => !isPowerOf2(matchUpsCount));
+  return hasOddMatchUpsCount && !(structure !== null && structure !== void 0 && structure.structures) && hasFirstRoundDrawPositions && noSecondRoundDrawPositions && !(drawDefinition !== null && drawDefinition !== void 0 && drawDefinition.drawType && drawDefinition.drawType !== LUCKY_DRAW);
+}
+
 function isAdHoc({
   drawDefinition,
   structure
@@ -10705,6 +10735,9 @@ function getRoundContextProfile({
   const isAdHocStructure = isAdHoc({
     structure
   });
+  const isLuckyStructure = isLucky({
+    structure
+  });
   const {
     roundProfile
   } = getRoundMatchUps$1({
@@ -10722,12 +10755,14 @@ function getRoundContextProfile({
   const stageConstants = roundNamingPolicy === null || roundNamingPolicy === void 0 ? void 0 : roundNamingPolicy.stageConstants;
   const stageConstant = stageConstants && stageConstants[stage] || stageInitial;
 
-  if (isRoundRobin || isAdHocStructure) {
+  if (isRoundRobin || isAdHocStructure || isLuckyStructure) {
     Object.assign(roundNamingProfile, ...Object.keys(roundProfile).map(key => {
-      const profileSize = `R${key}`;
+      const roundName = `Round ${key}`;
+      const abbreviatedRoundName = `R${key}`;
       return {
         [key]: {
-          roundName: profileSize
+          roundName,
+          abbreviatedRoundName
         }
       };
     }));
@@ -11218,10 +11253,10 @@ function getAllStructureMatchUps({
 
   if (!structure) {
     return {
-      matchUps: [],
       collectionPositionMatchUps,
+      error: MISSING_STRUCTURE,
       roundMatchUps,
-      error: MISSING_STRUCTURE
+      matchUps: []
     };
   }
 
@@ -14002,7 +14037,7 @@ function bulkScheduleMatchUps({
     const {
       tournamentId
     } = tournamentRecord;
-    const matchUpIds = matchUpContextIds.filter(contextIds => contextIds.tournamentId === tournamentId).map(getMatchUpId$1);
+    const matchUpIds = matchUpContextIds.filter(contextIds => contextIds.tournamentId === tournamentId).map(getMatchUpId);
 
     if (matchUpIds !== null && matchUpIds !== void 0 && matchUpIds.length) {
       const result = bulkScheduleMatchUps$1({
@@ -14391,7 +14426,11 @@ function validateSchedulingProfile({
     });
     return validVenues;
   });
-  if (!isValid && !error) error = INVALID_VALUES;
+
+  if (!isValid && !error) {
+    error = INVALID_VALUES;
+  }
+
   return {
     valid: !!isValid,
     error,
@@ -14431,8 +14470,9 @@ function tournamentRelevantSchedulingIds({
           drawDefinition
         });
         (structures || []).forEach(structure => {
+          var _structure$structures;
+
           const structureId = structure.structureId;
-          structureIds.push(structureId);
           const {
             matchUps
           } = getAllStructureMatchUps({
@@ -14445,6 +14485,14 @@ function tournamentRelevantSchedulingIds({
           });
           const rounds = roundMatchUps && Object.keys(roundMatchUps).map(roundNumber => parseInt(roundNumber));
           tournamentMap[tournamentId][eventId][drawId][structureId] = rounds;
+          structureIds.push(structureId);
+
+          if ((_structure$structures = structure.structures) !== null && _structure$structures !== void 0 && _structure$structures.length) {
+            structure.structures.forEach(itemStructure => {
+              structureIds.push(itemStructure.structureId);
+              tournamentMap[tournamentId][eventId][drawId][itemStructure.structureId] = rounds;
+            });
+          }
         });
       });
     });
@@ -19823,13 +19871,6 @@ function setMatchUpStatus$2(params) {
     return {
       error: INVALID_MATCHUP_STATUS
     };
-  }
-
-  if (score) {
-    const result = validateScore({
-      score
-    });
-    if (result.error) return result;
   } // Get map of all drawMatchUps and inContextDrawMatchUPs ---------------------
 
 
@@ -19857,6 +19898,16 @@ function setMatchUpStatus$2(params) {
   })); // Find target matchUp ------------------------------------------------------
 
   const matchUp = matchUpsMap.drawMatchUps.find(matchUp => matchUp.matchUpId === matchUpId);
+
+  if (score) {
+    const result = validateScore({
+      score,
+      matchUp,
+      winningSide
+    });
+    if (result.error) return result;
+  }
+
   const inContextMatchUp = inContextDrawMatchUps.find(matchUp => matchUp.matchUpId === matchUpId);
   if (!matchUp || !inContextDrawMatchUps) return {
     error: MATCHUP_NOT_FOUND
@@ -24527,7 +24578,7 @@ function getScheduledRoundsDetails({
     const matchUpIds = roundMatchUps.filter(({
       matchUpStatus
     }) => // don't attempt to scheduled completed matchUpstatuses
-    !completedMatchUpStatuses.includes(matchUpStatus) && matchUpStatus !== BYE).map(getMatchUpId$1);
+    !completedMatchUpStatuses.includes(matchUpStatus) && matchUpStatus !== BYE).map(getMatchUpId);
     matchUpIds.forEach(matchUpId => {
       minutesMap[matchUpId] = {
         typeChangeRecoveryMinutes,
@@ -24716,7 +24767,7 @@ function calculateScheduleTimes({
   } = getScheduleTimes(timingParameters); // if a single venue specified, or only one venue available, return venueId
 
   const venueId = (venueIds === null || venueIds === void 0 ? void 0 : venueIds.length) === 1 ? venueIds[0] : (venues === null || venues === void 0 ? void 0 : venues.length) === 1 ? venues[0].venueId : undefined;
-  const dateScheduledMatchUpIds = relevantMatchUps.map(getMatchUpId$1);
+  const dateScheduledMatchUpIds = relevantMatchUps.map(getMatchUpId);
   return {
     venueId,
     scheduleTimes,
@@ -25558,7 +25609,7 @@ function clearScheduledMatchUps$1({
   const relevantMatchUpIds = matchUps.filter(matchUp => !ignoreMatchUpStatuses.includes(matchUp.matchUpStatus) && hasSchedule({
     schedule: matchUp.schedule,
     scheduleAttributes
-  }) && (!(venueIds !== null && venueIds !== void 0 && venueIds.length) || venueIds.includes(matchUp.schedule.venueId))).map(getMatchUpId$1);
+  }) && (!(venueIds !== null && venueIds !== void 0 && venueIds.length) || venueIds.includes(matchUp.schedule.venueId))).map(getMatchUpId);
   const clearedScheduleValues = {
     venueId: '',
     scheduledDate: '',
@@ -25859,7 +25910,7 @@ function generateScheduleTimes({
   } = getScheduleTimes(timingParameters); // if a single venue specified, or only one venue available, return venueId
 
   const venueId = (venueIds === null || venueIds === void 0 ? void 0 : venueIds.length) === 1 ? venueIds[0] : (venues === null || venues === void 0 ? void 0 : venues.length) === 1 ? venues[0].venueId : undefined;
-  const dateScheduledMatchUpIds = dateScheduledMatchUps.map(getMatchUpId$1);
+  const dateScheduledMatchUpIds = dateScheduledMatchUps.map(getMatchUpId);
   return {
     venueId,
     scheduleTimes,
@@ -26011,8 +26062,8 @@ function jinnScheduler({
         orderedMatchUpIds,
         minutesMap
       } = getScheduledRoundsDetails({
-        tournamentRecords,
         containedStructureIds,
+        tournamentRecords,
         periodLength,
         matchUps,
         rounds
@@ -26351,7 +26402,7 @@ function jinnScheduler({
           });
         }
       });
-      noTimeMatchUpIds[scheduleDate] = venueScheduledRoundDetails[venueId].matchUpsToSchedule.map(getMatchUpId$1);
+      noTimeMatchUpIds[scheduleDate] = venueScheduledRoundDetails[venueId].matchUpsToSchedule.map(getMatchUpId);
       scheduleTimesRemaining[scheduleDate][venueId] = venueScheduledRoundDetails[venueId].scheduleTimes.sort((a, b) => timeStringMinutes(a.scheduleTime) - timeStringMinutes(b.scheduleTime));
     }
   } // returns the original form of the dateStrings, before extractDate()
@@ -31065,123 +31116,70 @@ const structureTemplate = ({
   return structure;
 };
 
-function treeMatchUps({
-  qualifyingRoundNumber,
-  // round at which participants qualify
-  finishingPositionOffset,
-  qualifyingPositions,
-  // number of positions which qualify
-  matchUpType,
-  roundLimit,
-  idPrefix,
-  drawSize,
-  isMock,
-  uuids
-}) {
-  if (isNaN(drawSize) || !isPowerOf2(drawSize) || drawSize < 2) {
-    return {
-      matchUps: [],
-      roundsCount: 0
-    };
-  }
-
-  const nodes = generateRange(1, parseInt(drawSize) + 1).map(drawPosition => ({
-    drawPosition
-  }));
-  let roundNodes;
-  let matchUps = [];
-  let roundNumber = 1;
-  ({
-    roundNodes,
-    matchUps
-  } = buildRound({
-    roundNumber,
-    matchUpType,
-    idPrefix,
-    matchUps,
-    isMock,
-    nodes,
-    uuids
-  }));
-  roundNumber++;
-  roundLimit = roundLimit || qualifyingRoundNumber;
-
-  while (roundNodes.length > 1) {
-    if (qualifyingPositions && roundNodes.length === qualifyingPositions) roundLimit = roundNumber - 1;
-    ({
-      roundNodes,
-      matchUps
-    } = buildRound({
-      nodes: roundNodes,
-      roundNumber,
-      matchUpType,
-      idPrefix,
-      matchUps,
-      isMock,
-      uuids
-    }));
-    roundNumber++;
-  }
-
-  const roundsCount = roundNumber - 1;
-  matchUps = addFinishingRounds({
-    finishingPositionOffset,
-    roundsCount,
-    roundLimit,
-    matchUps
-  });
-
-  if (roundLimit) {
-    matchUps = matchUps.filter(matchUp => matchUp.roundNumber <= roundLimit);
-  }
-
-  return {
-    matchUps,
-    roundsCount,
-    roundLimit
-  };
-}
-
 function addFinishingRounds({
   finishingPositionOffset = 0,
   positionsFed,
   roundsCount,
   roundLimit,
   matchUps,
+  lucky,
   fmlc
 }) {
-  // object containing # of matchUps (value) for each round (attribute)
-  const roundMatchCounts = matchUps.reduce((p, matchUp) => {
-    p[matchUp.roundNumber] = (p[matchUp.roundNumber] || 0) + 1;
-    return p;
-  }, {}); // array of # of matchUps (value) for eaach round (index)
+  const {
+    roundProfile,
+    roundNumbers
+  } = getRoundMatchUps$1({
+    matchUps
+  }); // array of # of matchUps (value) for eaach round (index)
 
-  const roundMatchCountArray = Object.values(roundMatchCounts); // returns a range for array of possible finishing drawPositions
+  const roundMatchUpsCountArray = Object.values(roundProfile).map(({
+    matchUpsCount
+  }) => matchUpsCount); // returns a range for array of possible finishing drawPositions
 
   const finishingRange = drawPositions => [Math.min(...drawPositions), Math.max(...drawPositions)]; // for qualifying, offset the final round so that qualifyinground is finishingRound
 
 
   const finishingRoundOffset = roundLimit ? roundsCount - roundLimit : 0;
-  matchUps.forEach(matchUp => {
-    matchUp.finishingRound = roundsCount + 1 - matchUp.roundNumber - finishingRoundOffset; // in the case of FMLC the finishingPositionRange in consolation is not modified after first fed round
+  const roundFinishingData = Object.assign({}, ...roundNumbers.map(roundNumber => {
+    const finishingRound = roundsCount + 1 - roundNumber - finishingRoundOffset;
+    const matchUpsCount = roundProfile[roundNumber].matchUpsCount;
+    const finishingData = {
+      finishingRound
+    };
+    const upcomingMatchUps = roundMatchUpsCountArray.slice(roundNumber - 1).reduce((a, b) => a + b, 0); // in the case of FMLC the finishingPositionRange in consolation is not modified after first fed round
 
-    const fmlcException = fmlc && matchUp.roundNumber !== 1;
+    const fmlcException = fmlc && roundNumber !== 1;
     const rangeOffset = 1 + finishingPositionOffset + (fmlcException ? positionsFed : 0);
-    const currentMatchUps = roundMatchCounts[matchUp.roundNumber];
-    const upcomingMatchUps = roundMatchCountArray.slice(matchUp.roundNumber - 1).reduce((a, b) => a + b, 0);
     const finalPosition = 1;
-    const finishingPositionRange = generateRange(rangeOffset, upcomingMatchUps + rangeOffset + finalPosition);
-    const slicer = upcomingMatchUps + finalPosition - currentMatchUps;
-    const loser = finishingRange(finishingPositionRange.slice(slicer));
-    const winner = finishingRange(finishingPositionRange.slice(0, slicer));
-    matchUp.finishingPositionRange = {
+    const positionRange = generateRange(rangeOffset, lucky ? rangeOffset + matchUpsCount * 2 : upcomingMatchUps + rangeOffset + finalPosition);
+    const slicer = upcomingMatchUps + finalPosition - matchUpsCount;
+    const loser = finishingRange(positionRange.slice(slicer));
+    const winner = finishingRange(positionRange.slice(0, slicer));
+    finishingData.finishingPositionRange = {
       loser,
       winner
     };
+    return {
+      [roundNumber]: finishingData
+    };
+  }));
+  matchUps.forEach(matchUp => {
+    const roundData = roundFinishingData[matchUp.roundNumber];
+    matchUp.finishingRound = roundData.finishingRound;
+    matchUp.finishingPositionRange = roundData.finishingPositionRange;
   });
   return matchUps;
 }
 
+function generateMatchUpId({
+  idPrefix,
+  roundNumber,
+  roundPosition,
+  uuids
+}) {
+  return idPrefix ? `${idPrefix}-${roundNumber}-${roundPosition}` : (uuids === null || uuids === void 0 ? void 0 : uuids.pop()) || UUID();
+}
+
 function buildRound({
   includeMatchUpType,
   matchUpType,
@@ -31203,7 +31201,7 @@ function buildRound({
     const child2 = nodes[index + 1];
     if (matchRoundNumber) child1.roundNumber = matchRoundNumber;
     if (child2 && matchRoundNumber) child2.roundNumber = matchRoundNumber;
-    const matchUpId = getMatchUpId({
+    const matchUpId = generateMatchUpId({
       roundPosition,
       roundNumber,
       idPrefix,
@@ -31229,8 +31227,8 @@ function buildRound({
     if (includeMatchUpType) matchUp.matchUpType = matchUpType;
     if (isMock) matchUp.isMock = true;
     matchUps.push(matchUp);
-    index += 2;
     roundPosition++;
+    index += 2;
   }
 
   return {
@@ -31239,247 +31237,103 @@ function buildRound({
   };
 }
 
-function roundMatchCounts({
-  drawSize
-}) {
-  const rounds = Math.ceil(Math.log(drawSize) / Math.log(2));
-  const range = generateRange(0, rounds).reverse();
-  return range.map(r => Math.pow(2, r));
-}
-
-function feedInMatchUps({
-  linkFedFinishingRoundNumbers = [],
-  linkFedRoundNumbers = [],
+function treeMatchUps({
+  qualifyingRoundNumber,
+  // round at which participants qualify
   finishingPositionOffset,
-  feedRoundsProfile = [],
-  feedRounds = 0,
-  skipRounds = 0,
-  feedsFromFinal,
-  isConsolation,
-  baseDrawSize,
+  qualifyingPositions,
+  // number of positions which qualify
   matchUpType,
+  roundLimit,
   idPrefix,
   drawSize,
   isMock,
-  uuids,
-  fmlc
+  uuids
 }) {
-  // calculate the number of rounds and the number of matchUps in each round
-  // for normal elimination structure
-  baseDrawSize = baseDrawSize || getBaseDrawSize(drawSize);
-  const baseDrawRounds = roundMatchCounts({
-    drawSize: baseDrawSize
-  });
-  const baseRoundsCount = baseDrawRounds.length;
-  let positionsFed = 0;
-
-  if (feedRoundsProfile.length) {
-    positionsFed = feedRoundsProfile.reduce((a, b) => a + b, 0);
-  } else if (drawSize) {
-    // having a drawSize defined trumps other configuration options
-    let positionsToFeed = drawSize - baseDrawSize;
-    feedRoundsProfile = baseDrawRounds.filter(feedSize => {
-      if (feedSize <= positionsToFeed) {
-        positionsToFeed -= feedSize;
-        return true;
-      }
-
-      return false;
-    });
-    positionsFed = feedRoundsProfile.reduce((a, b) => a + b, 0);
-    feedRounds = feedRoundsProfile.length;
-  } else {
-    // if skipRounds is set higher than baseRoundsCount then there are no feedRounds
-    if (skipRounds >= baseRoundsCount) feedRounds = 0; // if feedsFromFinal is defined, calculate number of feed rounds from Final Match
-    // e.g. feedsFromFinal is 1 for Semifinal, 2 for QuarterFinals, 3 for Round of 16
-
-    if (feedsFromFinal) {
-      feedRounds = baseRoundsCount - feedsFromFinal;
-      skipRounds = 0;
-    } // Given the above, feedsFromFinal trumps skipRounds
-    // and skipRounds >= baseRoundsCount negates feedRounds
-
-
-    feedRoundsProfile = baseDrawRounds.filter((feedSize, i) => {
-      if (feedsFromFinal && !feedRounds) return 0;
-      if (feedRounds && i >= skipRounds + feedRounds) return 0;
-      if (i < skipRounds) return 0;
-      return feedSize;
-    });
-    positionsFed = feedRoundsProfile.reduce((a, b) => a + b, 0);
-    drawSize = baseDrawSize + positionsFed;
-    feedRounds = feedRoundsProfile.length;
+  if (isNaN(drawSize) || !isPowerOf2(drawSize) || drawSize < 2) {
+    return {
+      matchUps: [],
+      roundsCount: 0
+    };
   }
 
-  const allRounds = [...baseDrawRounds, ...feedRoundsProfile].sort((a, b) => b - a);
-  const roundsCount = allRounds.length; // rounds which have linkFed participants can be specified two ways:
-  // linkFedRoundNumbers[] and linkFedFinishingRoundNumbers[]
-  // the difference being which end of the draw structure === 1
-
-  const linkFedRoundNumbersIndices = [...linkFedRoundNumbers.map(n => n - 1), ...linkFedFinishingRoundNumbers.map(n => roundsCount - n)]; // positionsFedByLinks can be determined by summing the values in allRounds
-  // which are found at linkFedRoundNumbersIndices
-
-  const positionsFedByLinks = linkFedRoundNumbersIndices.map(i => allRounds[i]).reduce((a, b) => a + b, 0);
-  positionsFed = positionsFed - positionsFedByLinks; // initialize round creation variables
-
-  let fed = 0; // keep track of even/odd feed rounds
-
-  let matchUps = []; // accumulate matchUps
-
-  let roundNodes; // an array of nodes
-
-  let roundNumber = 1; // initial roundNumber
-  // firstRoundDrawPositions are generated and assigned drawPositions
-
-  const firstRoundDrawPositions = generateRange(0, baseDrawSize).map((x, i) => ({
-    drawPosition: i + 1 + positionsFed
-  })); // initial nodes fed into buildRound
-
-  let nodes = firstRoundDrawPositions; // drawPosition within structure; offset used for feedRounds
+  const nodes = generateRange(1, parseInt(drawSize) + 1).map(drawPosition => ({
+    drawPosition
+  }));
+  let roundNodes;
+  let matchUps = [];
+  let roundNumber = 1;
+  ({
+    roundNodes,
+    matchUps
+  } = buildRound({
+    roundNumber,
+    matchUpType,
+    idPrefix,
+    matchUps,
+    isMock,
+    nodes,
+    uuids
+  }));
+  roundNumber++;
+  roundLimit = roundLimit || qualifyingRoundNumber;
 
-  let drawPosition = positionsFed + 1;
+  while (roundNodes.length > 1) {
+    if (qualifyingPositions && roundNodes.length === qualifyingPositions) {
+      roundLimit = roundNumber - 1;
+    }
 
-  for (const baseDrawRound of baseDrawRounds) {
     ({
       roundNodes,
       matchUps
     } = buildRound({
+      nodes: roundNodes,
       roundNumber,
       matchUpType,
       idPrefix,
       matchUps,
       isMock,
-      nodes,
       uuids
     }));
     roundNumber++;
-
-    if (feedRoundsProfile.includes(baseDrawRound)) {
-      const roundIterations = instanceCount(feedRoundsProfile)[baseDrawRound];
-      const iterationRange = generateRange(0, roundIterations);
-      const finishingRoundNumber = roundsCount + 1 - roundNumber;
-      const isLinkFedRound = linkFedFinishingRoundNumbers.includes(finishingRoundNumber) || linkFedRoundNumbers.includes(roundNumber);
-
-      for (const roundIteration of iterationRange) {
-        const iterationDrawPosition = !isLinkFedRound && drawPosition || undefined;
-        ({
-          roundNodes,
-          matchUps,
-          drawPosition
-        } = buildFeedRound({
-          drawPosition: iterationDrawPosition,
-          nodes: roundNodes,
-          roundIteration,
-          // meaningless; avoids eslint value never used
-          roundNumber,
-          matchUpType,
-          idPrefix,
-          matchUps,
-          uuids,
-          fed
-        }));
-        roundNumber++;
-        fed += 1;
-      }
-    }
-
-    nodes = roundNodes;
   }
 
-  if (roundsCount !== roundNumber - 1) console.log('ERROR'); // if this is a feed-in consolation then finishing drawPositions must be offset ...
-  // ... by the number of drawPositions which will be fed into the consolation draw
-  // final drawPositions will be played off twice up until the final feed round
-
-  const consolationFinish = baseDrawSize - positionsFed;
-  const modifiedFinishingPositionOffset = isConsolation ? consolationFinish : finishingPositionOffset;
+  const roundsCount = roundNumber - 1;
   matchUps = addFinishingRounds({
-    finishingPositionOffset: modifiedFinishingPositionOffset,
-    positionsFed,
+    finishingPositionOffset,
     roundsCount,
-    matchUps,
-    fmlc
+    roundLimit,
+    matchUps
   });
-  const draw = roundNodes && roundNodes.length ? roundNodes[0] : roundNodes;
-
-  if (draw) {
-    draw.roundNumber = roundNumber - 1;
-    draw.matchUps = matchUps;
-  }
-
-  return {
-    draw,
-    matchUps,
-    roundsCount
-  };
-
-  function getBaseDrawSize(drawSize) {
-    const nearestP2 = nearestPowerOf2(drawSize);
-    return nearestP2 > drawSize ? nearestP2 / 2 : nearestP2;
-  }
-}
-
-function buildFeedRound({
-  includeMatchUpType,
-  drawPosition,
-  matchUpType,
-  roundNumber,
-  idPrefix,
-  matchUps,
-  uuids,
-  nodes,
-  fed
-}) {
-  const feedRoundMatchUpsCount = nodes.length;
-  const initialGroupDrawPosition = drawPosition ? drawPosition - feedRoundMatchUpsCount : undefined;
-  const drawPositionGroup = generateRange(0, feedRoundMatchUpsCount).map(value => initialGroupDrawPosition ? initialGroupDrawPosition + value : undefined);
-  const roundNodes = [];
 
-  for (let nodeIndex = 0; nodeIndex < feedRoundMatchUpsCount; nodeIndex++) {
-    const feedDrawPosition = drawPositionGroup.shift();
-    const feedArm = {
-      feed: true,
-      fed: fed + 1,
-      drawPosition: feedDrawPosition
-    };
-    const position = nodes[nodeIndex];
-    position.roundNumber = roundNumber - 1;
-    const matchUpId = getMatchUpId({
-      roundPosition: position.roundPosition,
-      roundNumber,
-      idPrefix,
-      uuids
-    });
-    const newMatchUp = {
-      roundNumber,
-      matchUpId,
-      roundPosition: position.roundPosition,
-      drawPositions: [undefined, feedDrawPosition]
-    }; // matchUpType is derived for inContext matchUps from structure or drawDefinition
-
-    if (includeMatchUpType) newMatchUp.matchUpType = matchUpType;
-    matchUps.push(newMatchUp);
-    const roundNode = {
-      children: [position, feedArm]
-    };
-    roundNodes.push(roundNode);
+  if (roundLimit) {
+    matchUps = matchUps.filter(matchUp => matchUp.roundNumber <= roundLimit);
   }
 
-  const nextDrawPosition = drawPosition ? drawPosition - feedRoundMatchUpsCount : undefined;
   return {
-    roundNodes,
     matchUps,
-    drawPosition: nextDrawPosition
+    roundsCount,
+    roundLimit
   };
 }
-
-function getMatchUpId({
-  idPrefix,
-  roundNumber,
-  roundPosition,
-  uuids
-}) {
-  return idPrefix ? `${idPrefix}-${roundNumber}-${roundPosition}` : (uuids === null || uuids === void 0 ? void 0 : uuids.pop()) || UUID();
+/*
+export function feedDrawSize({ opponentCount }) {
+  const baseRanges = generateRange(0, 10).map((i) => {
+    const positionsBase = Math.pow(2, i);
+    const feedPositions = positionsBase - 1;
+    const maxByes = positionsBase / 2 - 1;
+    const maxPositions = positionsBase + feedPositions;
+    const positionRange = { positionsBase, maxPositions, maxByes };
+    return positionRange;
+  });
+  const positionsBase = baseRanges.reduce((p, c) => {
+    return opponentCount >= c.positionsBase && opponentCount <= c.maxPositions
+      ? c
+      : p;
+  }, undefined);
+  return positionsBase;
 }
+*/
 
 function generateVoluntaryConsolationStructure$1({
   structureName = VOLUNTARY_CONSOLATION,
@@ -32561,6 +32415,239 @@ function generateTieMatchUps({
   };
 }
 
+function buildFeedRound({
+  includeMatchUpType,
+  drawPosition,
+  matchUpType,
+  roundNumber,
+  idPrefix,
+  matchUps,
+  uuids,
+  nodes,
+  fed
+}) {
+  const feedRoundMatchUpsCount = nodes.length;
+  const initialGroupDrawPosition = drawPosition ? drawPosition - feedRoundMatchUpsCount : undefined;
+  const drawPositionGroup = generateRange(0, feedRoundMatchUpsCount).map(value => initialGroupDrawPosition ? initialGroupDrawPosition + value : undefined);
+  const roundNodes = [];
+
+  for (let nodeIndex = 0; nodeIndex < feedRoundMatchUpsCount; nodeIndex++) {
+    const feedDrawPosition = drawPositionGroup.shift();
+    const feedArm = {
+      feed: true,
+      fed: fed + 1,
+      drawPosition: feedDrawPosition
+    };
+    const position = nodes[nodeIndex];
+    position.roundNumber = roundNumber - 1;
+    const matchUpId = generateMatchUpId({
+      roundPosition: position.roundPosition,
+      roundNumber,
+      idPrefix,
+      uuids
+    });
+    const newMatchUp = {
+      roundNumber,
+      matchUpId,
+      roundPosition: position.roundPosition,
+      drawPositions: [undefined, feedDrawPosition]
+    }; // matchUpType is derived for inContext matchUps from structure or drawDefinition
+
+    if (includeMatchUpType) newMatchUp.matchUpType = matchUpType;
+    matchUps.push(newMatchUp);
+    const roundNode = {
+      children: [position, feedArm]
+    };
+    roundNodes.push(roundNode);
+  }
+
+  const nextDrawPosition = drawPosition ? drawPosition - feedRoundMatchUpsCount : undefined;
+  return {
+    roundNodes,
+    matchUps,
+    drawPosition: nextDrawPosition
+  };
+}
+
+function feedInMatchUps({
+  linkFedFinishingRoundNumbers = [],
+  linkFedRoundNumbers = [],
+  finishingPositionOffset,
+  feedRoundsProfile = [],
+  feedRounds = 0,
+  skipRounds = 0,
+  feedsFromFinal,
+  isConsolation,
+  baseDrawSize,
+  matchUpType,
+  idPrefix,
+  drawSize,
+  isMock,
+  uuids,
+  fmlc
+}) {
+  // calculate the number of rounds and the number of matchUps in each round
+  // for normal elimination structure
+  baseDrawSize = baseDrawSize || getBaseDrawSize(drawSize);
+  const baseDrawRounds = roundMatchCounts({
+    drawSize: baseDrawSize
+  });
+  const baseRoundsCount = baseDrawRounds.length;
+  let positionsFed = 0;
+
+  if (feedRoundsProfile.length) {
+    positionsFed = feedRoundsProfile.reduce((a, b) => a + b, 0);
+  } else if (drawSize) {
+    // having a drawSize defined trumps other configuration options
+    let positionsToFeed = drawSize - baseDrawSize;
+    feedRoundsProfile = baseDrawRounds.filter(feedSize => {
+      if (feedSize <= positionsToFeed) {
+        positionsToFeed -= feedSize;
+        return true;
+      }
+
+      return false;
+    });
+    positionsFed = feedRoundsProfile.reduce((a, b) => a + b, 0);
+    feedRounds = feedRoundsProfile.length;
+  } else {
+    // if skipRounds is set higher than baseRoundsCount then there are no feedRounds
+    if (skipRounds >= baseRoundsCount) feedRounds = 0; // if feedsFromFinal is defined, calculate number of feed rounds from Final Match
+    // e.g. feedsFromFinal is 1 for Semifinal, 2 for QuarterFinals, 3 for Round of 16
+
+    if (feedsFromFinal) {
+      feedRounds = baseRoundsCount - feedsFromFinal;
+      skipRounds = 0;
+    } // Given the above, feedsFromFinal trumps skipRounds
+    // and skipRounds >= baseRoundsCount negates feedRounds
+
+
+    feedRoundsProfile = baseDrawRounds.filter((feedSize, i) => {
+      if (feedsFromFinal && !feedRounds) return 0;
+      if (feedRounds && i >= skipRounds + feedRounds) return 0;
+      if (i < skipRounds) return 0;
+      return feedSize;
+    });
+    positionsFed = feedRoundsProfile.reduce((a, b) => a + b, 0);
+    drawSize = baseDrawSize + positionsFed;
+    feedRounds = feedRoundsProfile.length;
+  }
+
+  const allRounds = [...baseDrawRounds, ...feedRoundsProfile].sort((a, b) => b - a);
+  const roundsCount = allRounds.length; // rounds which have linkFed participants can be specified two ways:
+  // linkFedRoundNumbers[] and linkFedFinishingRoundNumbers[]
+  // the difference being which end of the draw structure === 1
+
+  const linkFedRoundNumbersIndices = [...linkFedRoundNumbers.map(n => n - 1), ...linkFedFinishingRoundNumbers.map(n => roundsCount - n)]; // positionsFedByLinks can be determined by summing the values in allRounds
+  // which are found at linkFedRoundNumbersIndices
+
+  const positionsFedByLinks = linkFedRoundNumbersIndices.map(i => allRounds[i]).reduce((a, b) => a + b, 0);
+  positionsFed = positionsFed - positionsFedByLinks; // initialize round creation variables
+
+  let fed = 0; // keep track of even/odd feed rounds
+
+  let matchUps = []; // accumulate matchUps
+
+  let roundNodes; // an array of nodes
+
+  let roundNumber = 1; // initial roundNumber
+  // firstRoundDrawPositions are generated and assigned drawPositions
+
+  const firstRoundDrawPositions = generateRange(0, baseDrawSize).map((x, i) => ({
+    drawPosition: i + 1 + positionsFed
+  })); // initial nodes fed into buildRound
+
+  let nodes = firstRoundDrawPositions; // drawPosition within structure; offset used for feedRounds
+
+  let drawPosition = positionsFed + 1;
+
+  for (const baseDrawRound of baseDrawRounds) {
+    ({
+      roundNodes,
+      matchUps
+    } = buildRound({
+      roundNumber,
+      matchUpType,
+      idPrefix,
+      matchUps,
+      isMock,
+      nodes,
+      uuids
+    }));
+    roundNumber++;
+
+    if (feedRoundsProfile.includes(baseDrawRound)) {
+      const roundIterations = instanceCount(feedRoundsProfile)[baseDrawRound];
+      const iterationRange = generateRange(0, roundIterations);
+      const finishingRoundNumber = roundsCount + 1 - roundNumber;
+      const isLinkFedRound = linkFedFinishingRoundNumbers.includes(finishingRoundNumber) || linkFedRoundNumbers.includes(roundNumber);
+
+      for (const roundIteration of iterationRange) {
+        const iterationDrawPosition = !isLinkFedRound && drawPosition || undefined;
+        ({
+          roundNodes,
+          matchUps,
+          drawPosition
+        } = buildFeedRound({
+          drawPosition: iterationDrawPosition,
+          nodes: roundNodes,
+          roundIteration,
+          // meaningless; avoids eslint value never used
+          roundNumber,
+          matchUpType,
+          idPrefix,
+          matchUps,
+          uuids,
+          fed
+        }));
+        roundNumber++;
+        fed += 1;
+      }
+    }
+
+    nodes = roundNodes;
+  }
+
+  if (roundsCount !== roundNumber - 1) console.log('ERROR'); // if this is a feed-in consolation then finishing drawPositions must be offset ...
+  // ... by the number of drawPositions which will be fed into the consolation draw
+  // final drawPositions will be played off twice up until the final feed round
+
+  const consolationFinish = baseDrawSize - positionsFed;
+  const modifiedFinishingPositionOffset = isConsolation ? consolationFinish : finishingPositionOffset;
+  matchUps = addFinishingRounds({
+    finishingPositionOffset: modifiedFinishingPositionOffset,
+    positionsFed,
+    roundsCount,
+    matchUps,
+    fmlc
+  });
+  const draw = roundNodes && roundNodes.length ? roundNodes[0] : roundNodes;
+
+  if (draw) {
+    draw.roundNumber = roundNumber - 1;
+    draw.matchUps = matchUps;
+  }
+
+  return {
+    draw,
+    matchUps,
+    roundsCount
+  };
+
+  function getBaseDrawSize(drawSize) {
+    const nearestP2 = nearestPowerOf2(drawSize);
+    return nearestP2 > drawSize ? nearestP2 / 2 : nearestP2;
+  }
+} // returns an array of the number of matchUps in each round of an elimination draw
+
+function roundMatchCounts({
+  drawSize
+}) {
+  const rounds = Math.ceil(Math.log(drawSize) / Math.log(2));
+  const range = generateRange(0, rounds).reverse();
+  return range.map(r => Math.pow(2, r));
+}
+
 function playoff(params) {
   const {
     structure,
@@ -32860,7 +32947,7 @@ function addPlayoffStructures$1(params) {
   });
   const addedMatchUpIds = inContextDrawMatchUps.filter(({
     structureId
-  }) => newStructureIds.includes(structureId)).map(getMatchUpId$1);
+  }) => newStructureIds.includes(structureId)).map(getMatchUpId);
   const addedMatchUps = matchUpsMap === null || matchUpsMap === void 0 ? void 0 : (_matchUpsMap$drawMatc = matchUpsMap.drawMatchUps) === null || _matchUpsMap$drawMatc === void 0 ? void 0 : _matchUpsMap$drawMatc.filter(({
     matchUpId
   }) => addedMatchUpIds.includes(matchUpId));
@@ -33479,7 +33566,7 @@ function generateQualifyingStructures({
   const sequenceSort = (a, b) => a.stageSequence - b.stageSequence;
 
   let qualifyingDrawPositionsCount = 0,
-      finalyQualifyingRoundNumber,
+      finalQualifyingRoundNumber,
       finalQualifyingStructureId,
       qualifiersCount = 0,
       stageSequence = 0;
@@ -33507,13 +33594,25 @@ function generateQualifyingStructures({
       isMock,
       uuids
     });
-    stageSequence += 1; // order of operations is important here!! finalyQualifier positions is not yet updated when this step occurs
+    stageSequence += 1;
+    const qualifyingStructureName = structureName || (qualifyingProfiles.length > 1 ? `${QUALIFYING} ${stageSequence}` : QUALIFYING);
+    const structure = structureTemplate({
+      structureName: qualifyingStructureName,
+      qualifyingRoundNumber: roundLimit,
+      structureId: uuids === null || uuids === void 0 ? void 0 : uuids.pop(),
+      stage: QUALIFYING,
+      stageSequence,
+      matchUpType,
+      roundLimit,
+      // redundant
+      matchUps
+    }); // order of operations is important here!! finalyQualifier positions is not yet updated when this step occurs
 
     if (stageSequence > 1) {
       generateQualifyingLink$1({
         sourceStructureId: finalQualifyingStructureId,
         targetStructureId: structure.structureId,
-        sourceRoundNumber: qualifyingRoundNumber,
+        sourceRoundNumber: finalQualifyingRoundNumber,
         drawDefinition
       }); // if more than one qualifying stageSequence, remove last stageSequence qualifier positions from count
 
@@ -33522,26 +33621,15 @@ function generateQualifyingStructures({
       qualifyingDrawPositionsCount += drawSize;
     }
 
-    const structure = structureTemplate({
-      structureName: structureName || QUALIFYING,
-      qualifyingRoundNumber: roundLimit,
-      structureId: uuids === null || uuids === void 0 ? void 0 : uuids.pop(),
-      stage: QUALIFYING,
-      stageSequence,
-      matchUpType,
-      roundLimit,
-      // redundant
-      matchUps
-    });
     qualifiersCount = (_matchUps$filter = matchUps.filter(matchUp => matchUp.roundNumber === roundLimit)) === null || _matchUps$filter === void 0 ? void 0 : _matchUps$filter.length;
     finalQualifyingStructureId = structure.structureId;
-    finalyQualifyingRoundNumber = roundLimit;
+    finalQualifyingRoundNumber = roundLimit;
     structures.push(structure);
   }
 
   return {
     qualifyingDrawPositionsCount,
-    finalyQualifyingRoundNumber,
+    finalQualifyingRoundNumber,
     finalQualifyingStructureId,
     qualifiersCount,
     structures,
@@ -33626,6 +33714,120 @@ function feedInChampionship(params = {}) {
   });
 }
 
+function luckyDraw(params) {
+  const {
+    qualifyingRoundNumber,
+    // round at which participants qualify
+    finishingPositionOffset,
+    qualifyingPositions,
+    // number of positions which qualify
+    matchUpType,
+    idPrefix,
+    drawSize,
+    isMock,
+    uuids
+  } = params;
+
+  if (!isConvertableInteger(drawSize) || drawSize < 2) {
+    return {
+      matchUps: [],
+      roundsCount: 0
+    };
+  }
+
+  if (isPowerOf2(drawSize)) return treeMatchUps(params);
+  const roundProfiles = luckyRoundProfiles(drawSize);
+  const firstRound = roundProfiles.shift();
+  const nodes = generateRange(1, firstRound.participantsCount + 1).map(drawPosition => ({
+    drawPosition
+  }));
+  let matchUps = [];
+  let roundNumber = 1;
+  ({
+    matchUps
+  } = buildRound({
+    roundNumber,
+    matchUpType,
+    idPrefix,
+    matchUps,
+    isMock,
+    nodes,
+    uuids
+  }));
+  roundNumber++;
+  let roundLimit = params.roundLimit || qualifyingRoundNumber;
+
+  for (const roundProfile of roundProfiles) {
+    const roundMatchUpsCount = roundProfile.participantsCount / 2;
+    const roundPositionRange = generateRange(1, roundMatchUpsCount + 1);
+
+    if (qualifyingPositions && roundMatchUpsCount === qualifyingPositions) {
+      roundLimit = roundNumber - 1;
+    }
+
+    const roundMatchUps = roundPositionRange.map(roundPosition => {
+      const matchUpId = generateMatchUpId({
+        roundPosition: roundPosition,
+        roundNumber,
+        idPrefix,
+        uuids
+      });
+      const newMatchUp = {
+        roundPosition,
+        roundNumber,
+        matchUpId
+      };
+      return newMatchUp;
+    });
+    matchUps.push(...roundMatchUps);
+    roundNumber++;
+  }
+
+  const roundsCount = roundNumber - 1;
+  matchUps = addFinishingRounds({
+    finishingPositionOffset,
+    lucky: true,
+    roundsCount,
+    roundLimit,
+    matchUps
+  });
+
+  if (roundLimit) {
+    matchUps = matchUps.filter(matchUp => matchUp.roundNumber <= roundLimit);
+  }
+
+  return {
+    matchUps,
+    roundsCount,
+    roundLimit
+  };
+}
+
+function luckyRoundProfiles(drawSize) {
+  const intDrawSize = parseInt(drawSize);
+  let participantsCount = intDrawSize % 2 ? intDrawSize + 1 : intDrawSize;
+  const preFeedRound = !!(Math.ceil(participantsCount / 2) % 2);
+  const rounds = [{
+    participantsCount,
+    preFeedRound
+  }];
+
+  while (participantsCount > 2) {
+    const nextRound = Math.ceil(participantsCount / 2);
+    const nextIsFinal = nextRound === 1;
+    const feedRound = !!(!nextIsFinal && nextRound % 2);
+    participantsCount = !nextIsFinal && feedRound ? nextRound + 1 : nextRound;
+    const preFeedRound = !!(participantsCount !== 2 && Math.ceil(participantsCount / 2) % 2);
+    rounds.push({
+      participantsCount,
+      preFeedRound,
+      feedRound
+    });
+  }
+
+  return rounds;
+}
+
 function generateRoundRobin({
   structureName = MAIN,
   stageSequence = 1,
@@ -34053,7 +34255,7 @@ function generateDrawType(params = {}) {
   }));
   const validDoubleEliminationSize = isPowerOf2(drawSize * 2 / 3); // check that drawSize is a valid value
 
-  const invalidDrawSize = drawSize < 2 || !staggeredEntry && ![FEED_IN$1, AD_HOC].includes(drawType) && (drawType === ROUND_ROBIN && drawSize < 3 || drawType === DOUBLE_ELIMINATION && !validDoubleEliminationSize || ![ROUND_ROBIN, DOUBLE_ELIMINATION, ROUND_ROBIN_WITH_PLAYOFF].includes(drawType) && !isPowerOf2(drawSize));
+  const invalidDrawSize = drawSize < 2 || !staggeredEntry && ![FEED_IN$1, AD_HOC, LUCKY_DRAW].includes(drawType) && (drawType === ROUND_ROBIN && drawSize < 3 || drawType === DOUBLE_ELIMINATION && !validDoubleEliminationSize || ![ROUND_ROBIN, DOUBLE_ELIMINATION, ROUND_ROBIN_WITH_PLAYOFF].includes(drawType) && !isPowerOf2(drawSize));
 
   if (invalidDrawSize) {
     return {
@@ -34099,6 +34301,23 @@ function generateDrawType(params = {}) {
         structures: [structure]
       }, SUCCESS);
     },
+    [LUCKY_DRAW]: () => {
+      const {
+        matchUps
+      } = luckyDraw(params);
+      const structure = structureTemplate({
+        structureName: structureName || MAIN,
+        structureId: uuids === null || uuids === void 0 ? void 0 : uuids.pop(),
+        stageSequence,
+        matchUpType,
+        stage: MAIN,
+        matchUps
+      });
+      drawDefinition.structures.push(structure);
+      return Object.assign({
+        structures: [structure]
+      }, SUCCESS);
+    },
     [SINGLE_ELIMINATION]: () => {
       const {
         matchUps
@@ -34180,17 +34399,17 @@ function generateDrawType(params = {}) {
 
   if (qualifyingResult !== null && qualifyingResult !== void 0 && (_qualifyingResult$str = qualifyingResult.structures) !== null && _qualifyingResult$str !== void 0 && _qualifyingResult$str.length) {
     const {
-      finalyQualifyingRoundNumber: qualifyingRoundNumber,
-      qualifyingStructureId
+      finalQualifyingRoundNumber: qualifyingRoundNumber,
+      finalQualifyingStructureId: qualifyingStructureId
     } = qualifyingResult;
-    const mainStructureId = generatorResult.structures.find(({
+    const mainStructure = generatorResult.structures.find(({
       stage,
       stageSequence
     }) => stage === MAIN && stageSequence === 1);
     generateQualifyingLink$1({
       sourceStructureId: qualifyingStructureId,
       sourceRoundNumber: qualifyingRoundNumber,
-      targetStructureId: mainStructureId,
+      targetStructureId: mainStructure.structureId,
       drawDefinition
     });
   }
@@ -37061,8 +37280,8 @@ function setOrderOfFinish$1({
     inContext: true,
     drawDefinition
   });
-  const matchUpIds = completedMatchUps.map(getMatchUpId$1);
-  const targetMatchUpIds = finishingOrder.map(getMatchUpId$1);
+  const matchUpIds = completedMatchUps.map(getMatchUpId);
+  const targetMatchUpIds = finishingOrder.map(getMatchUpId);
   const {
     matchUpTypes,
     roundNumbers,
@@ -39342,8 +39561,8 @@ function setParticipantScaleItem({
   };
 }
 function setParticipantScaleItems({
-  tournamentRecord,
-  scaleItemsWithParticipantIds = []
+  scaleItemsWithParticipantIds = [],
+  tournamentRecord
 }) {
   if (!tournamentRecord) return {
     error: MISSING_TOURNAMENT_RECORD
@@ -40310,9 +40529,10 @@ function modifyIndividualParticipantIds({
  */
 
 function generateTeamsFromParticipantAttribute({
-  tournamentRecord,
   participantAttribute,
+  tournamentRecord,
   personAttribute,
+  teamNames,
   accessor,
   uuids
 }) {
@@ -40324,6 +40544,7 @@ function generateTeamsFromParticipantAttribute({
     participantType,
     participantRole
   }) => participantType === INDIVIDUAL$1 && participantRole === COMPETITOR);
+  let teamIndex = 0;
 
   for (const individualParticipant of individualParticipants) {
     const {
@@ -40337,7 +40558,7 @@ function generateTeamsFromParticipantAttribute({
     if (attributeValue) {
       if (!Object.keys(teams).includes(attributeValue)) {
         teams[attributeValue] = {
-          participantName: attributeValue,
+          participantName: (teamNames === null || teamNames === void 0 ? void 0 : teamNames[teamIndex]) || attributeValue,
           participantId: (uuids === null || uuids === void 0 ? void 0 : uuids.pop()) || UUID(),
           participantType: TEAM$1,
           participantRole: COMPETITOR,
@@ -40351,6 +40572,7 @@ function generateTeamsFromParticipantAttribute({
           element: teams[attributeValue],
           extension
         });
+        teamIndex += 1;
       }
 
       teams[attributeValue].individualParticipantIds.push(individualParticipant.participantId);
@@ -41371,11 +41593,11 @@ function getEventData({
 }
 
 function publishEvent({
-  tournamentRecord,
   policyDefinitions,
-  status = PUBLIC,
   structureIds = [],
+  tournamentRecord,
   drawIdsToRemove,
+  status = PUBLIC,
   drawIdsToAdd,
   drawIds,
   event
@@ -44926,11 +45148,11 @@ function removeDelegatedOutcome(params) {
 }
 
 function generateSeedingScaleItems({
+  scaleAttributes,
   scaledEntries,
+  stageEntries,
   seedsCount,
-  scaleAttributes,
-  scaleName,
-  stageEntries
+  scaleName
 }) {
   if (!scaleAttributes) return {
     error: MISSING_VALUE
@@ -49039,6 +49261,7 @@ function generatePersons({
     error: INVALID_VALUES
   };
   let validPersonData = defaultPersonData.filter(person => !sex || person.sex === sex);
+  let nationalityCodes = [];
 
   if (Array.isArray(personData)) {
     const validatedPersonData = personData.filter(person => {
@@ -49049,6 +49272,7 @@ function generatePersons({
         iso,
         ioc
       }) => [iso, ioc].includes(person.nationalityCode)))) return false;
+      if (person.nationalityCode) nationalityCodes.push(person.nationalityCode);
       return true;
     });
 
@@ -49133,7 +49357,8 @@ function generatePersons({
     }), person);
   });
   return {
-    persons: persons.length && persons || shuffledPersons[0]
+    persons: persons.length && persons || shuffledPersons[0],
+    nationalityCodes
   };
 }
 
@@ -50249,7 +50474,7 @@ function completeDrawMatchUps({
     });
     const sortedMatchUpIds = matchUps.filter(({
       winningSide
-    }) => !winningSide).sort(matchUpSort).map(getMatchUpId$1);
+    }) => !winningSide).sort(matchUpSort).map(getMatchUpId);
 
     for (const matchUpId of sortedMatchUpIds) {
       if (!isNaN(completionGoal) && completedCount >= completionGoal) break;
@@ -50575,6 +50800,7 @@ function generateParticipants({
   const team = participantType === TEAM$1 || matchUpType === TEAM$1;
   const individualParticipantsCount = participantsCount * (doubles ? 2 : team ? 8 : 1);
   const {
+    nationalityCodes: personNationalityCodes,
     persons: mockedPersons,
     error
   } = generatePersons({
@@ -50724,7 +50950,7 @@ function generateParticipants({
     const standardFamilyName = lastName || 'FamilyName';
     const participantName = `${standardGivenName} ${standardFamilyName}`;
     const country = countriesList[participantIndex];
-    const nationalityCode = country && (nationalityCodeType === 'ISO' ? country.iso : country.ioc || country.iso) || personNationalityCode;
+    const nationalityCode = (personNationalityCodes === null || personNationalityCodes === void 0 ? void 0 : personNationalityCodes.length) && personNationalityCode || country && (nationalityCodeType === 'ISO' ? country.iso : country.ioc || country.iso) || personNationalityCode;
 
     if (countriesList !== null && countriesList !== void 0 && countriesList.length && !nationalityCode && !personNationalityCode) {
       console.log('%c Invalid Nationality Code', {
@@ -50756,7 +50982,7 @@ function generateParticipants({
         standardGivenName,
         nationalityCode,
         extensions,
-        birthDate,
+        birthDate: isValidDateString(birthDate) ? birthDate : undefined,
         sex
       }
     });
@@ -51284,6 +51510,7 @@ function generateEventWithFlights({
   tournamentRecord,
   eventProfile,
   eventIndex,
+  publish,
   uuids
 }) {
   let gender = eventProfile.gender;
@@ -51413,6 +51640,14 @@ function generateEventWithFlights({
   });
   if (result.error) return result;
   const drawIds = result.drawIds;
+
+  if (publish) {
+    publishEvent({
+      tournamentRecord,
+      event
+    });
+  }
+
   return {
     drawIds,
     eventId,
@@ -51441,6 +51676,7 @@ function generateEventWithDraw({
     excessParticipantAlternates = true,
     matchUpFormat = FORMAT_STANDARD,
     drawType = SINGLE_ELIMINATION,
+    tournamentAlternates = 0,
     alternatesCount = 0,
     generate = true,
     eventExtensions,
@@ -51450,6 +51686,7 @@ function generateEventWithDraw({
     seedsCount,
     category,
     idPrefix,
+    publish,
     gender,
     stage
   } = drawProfile;
@@ -51594,7 +51831,7 @@ function generateEventWithDraw({
 
   const alternatesParticipantIds = excessParticipantAlternates && (tournamentRecord === null || tournamentRecord === void 0 ? void 0 : (_tournamentRecord$par = tournamentRecord.participants) === null || _tournamentRecord$par === void 0 ? void 0 : _tournamentRecord$par.filter(({
     participantId
-  }) => !participantIds.includes(participantId)).filter(isEventParticipantType).filter(isEventGender).slice(0, alternatesCount || drawSize - participantsCount).map(p => p.participantId));
+  }) => !participantIds.includes(participantId)).filter(isEventParticipantType).filter(isEventGender).slice(0, alternatesCount || drawSize - participantsCount || tournamentAlternates).map(p => p.participantId));
 
   if (alternatesParticipantIds !== null && alternatesParticipantIds !== void 0 && alternatesParticipantIds.length) {
     const result = addEventEntries({
@@ -51782,6 +52019,13 @@ function generateEventWithDraw({
 
       }
     }
+
+    if (publish) {
+      publishEvent({
+        tournamentRecord,
+        event
+      });
+    }
   }
 
   return { ...SUCCESS,
@@ -51929,7 +52173,8 @@ function modifyTournamentRecord({
           eventType
         } = event;
         const {
-          drawProfiles
+          drawProfiles,
+          publish
         } = eventProfile;
         const eventParticipantType = eventType === SINGLES ? INDIVIDUAL : eventType === DOUBLES ? PAIR : eventType;
 
@@ -51990,6 +52235,13 @@ function modifyTournamentRecord({
           if (result.error) return result;
           drawIds.push(...result.drawIds);
         }
+
+        if (publish) {
+          publishEvent({
+            tournamentRecord,
+            event
+          });
+        }
       }
     }
   }