tods-competition-factory 0.76.0 → 0.80.0

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

@@ -249,7 +249,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return '0.76.0';
+  return '0.80.0';
 }
 
 const FORMAT_STANDARD = 'SET3-S:6/TB7'; // Best of 3 Tiebreak Sets to 6
@@ -11813,7 +11813,7 @@ function getAllStructureMatchUps({
 
     if (tournamentParticipants && matchUpWithContext.sides) {
       matchUpWithContext.sides.filter(Boolean).forEach(side => {
-        var _side$participant;
+        var _side$participant, _side$participant$ind;
 
         if (side.participantId) {
           const participant = findParticipant({
@@ -11834,7 +11834,7 @@ function getAllStructureMatchUps({
           }
         }
 
-        if (side !== null && side !== void 0 && (_side$participant = side.participant) !== null && _side$participant !== void 0 && _side$participant.individualParticipantIds) {
+        if (side !== null && side !== void 0 && (_side$participant = side.participant) !== null && _side$participant !== void 0 && (_side$participant$ind = _side$participant.individualParticipantIds) !== null && _side$participant$ind !== void 0 && _side$participant$ind.length) {
           const individualParticipants = side.participant.individualParticipantIds.map(participantId => {
             return findParticipant({
               policyDefinitions: appliedPolicies,
@@ -15670,10 +15670,10 @@ function getMatchUpDependencies({
           const {
             drawDefinition
           } = findEvent({
-            tournamentRecord: tournamentRecords[hasTournamentId.tournamentId],
+            tournamentRecord: tournamentRecords[hasTournamentId === null || hasTournamentId === void 0 ? void 0 : hasTournamentId.tournamentId],
             drawId
           });
-          addGoesTo({
+          if (drawDefinition) addGoesTo({
             drawDefinition
           });
         }
@@ -22077,7 +22077,8 @@ function addParticipant$1({
   if (!participant.participantId) participant.participantId = UUID();
   if (!tournamentRecord.participants) tournamentRecord.participants = [];
   const {
-    participantId
+    participantId,
+    individualParticipantIds
   } = participant;
   const idExists = tournamentRecord.participants.reduce((p, c) => c.participantId === participantId || p, false);
   if (idExists) return {
@@ -22096,6 +22097,14 @@ function addParticipant$1({
   };
   const tournamentParticipants = tournamentRecord.participants || [];
   const tournamentIndividualParticipantIds = tournamentParticipants.filter(tournamentParticipant => tournamentParticipant.participantType === INDIVIDUAL$1).map(individualParticipant => individualParticipant.participantId);
+  if (participantType !== INDIVIDUAL$1 && participant.person) return {
+    error: INVALID_VALUES,
+    person: participant.person
+  };
+  if (individualParticipantIds && !Array.isArray(individualParticipantIds)) return {
+    error: INVALID_VALUES,
+    individualParticipantIds
+  };
 
   if (participantType === PAIR$1) {
     if (participant.person) return {
@@ -22124,8 +22133,8 @@ function addParticipant$1({
     }
 
     const existingPairParticipants = tournamentParticipants.filter(participant => participant.participantType === PAIR$1).map(participant => ({
-      participant,
-      individualParticipantIds: participant.individualParticipantIds
+      individualParticipantIds: participant.individualParticipantIds,
+      participant
     })); // determine whether a PAIR participant already exists
 
     const existingPairParticipant = participant.participantType === PAIR$1 && existingPairParticipants.find(existingPairParticipant => intersection(existingPairParticipant.individualParticipantIds, participant.individualParticipantIds).length === 2);
@@ -22159,17 +22168,11 @@ function addParticipant$1({
       participant.participantName = participantName;
       participant.name = participantName; // backwards compatabilty
     }
-  } else {
-    if (participant.person) return {
-      error: INVALID_VALUES,
-      person: participant.person
-    };
-    const {
-      individualParticipantIds
-    } = participant;
+  } else if ([TEAM$1, GROUP].includes(participantType)) {
+    if (!individualParticipantIds) participant.individualParticipantIds = [];
 
-    if (individualParticipantIds !== null && individualParticipantIds !== void 0 && individualParticipantIds.length) {
-      for (const individualParticipantId of individualParticipantIds) {
+    if (participant.individualParticipantIds.length) {
+      for (const individualParticipantId of participant.individualParticipantIds) {
         if (typeof individualParticipantId !== 'string') {
           return {
             error: INVALID_VALUES,
@@ -22185,6 +22188,10 @@ function addParticipant$1({
         }
       }
     }
+  } else {
+    return {
+      error: INVALID_PARTICIPANT_TYPE
+    };
   }
 
   tournamentRecord.participants.push(participant);
@@ -23375,7 +23382,7 @@ function getTournamentParticipants({
   if (!tournamentRecord.participants) return {
     error: MISSING_PARTICIPANTS
   };
-  let tournamentParticipants = tournamentRecord.participants.map(participant => makeDeepCopy(participant, convertExtensions));
+  let tournamentParticipants = tournamentRecord.participants.map(participant => makeDeepCopy(participant, convertExtensions, true));
   if (typeof participantFilters !== 'object') return {
     error: INVALID_OBJECT,
     participantFilters
@@ -23386,7 +23393,9 @@ function getTournamentParticipants({
 
     (_tournamentParticipan = tournamentParticipants) === null || _tournamentParticipan === void 0 ? void 0 : _tournamentParticipan.forEach(participant => {
       if ([PAIR$1, TEAM$1, GROUP].includes(participant.participantType)) {
-        participant.individualParticipants = participant.individualParticipantIds.map(participantId => {
+        var _participant$individu;
+
+        participant.individualParticipants = (_participant$individu = participant.individualParticipantIds) === null || _participant$individu === void 0 ? void 0 : _participant$individu.map(participantId => {
           const individualParticipant = tournamentRecord.participants.find(p => p.participantId === participantId);
           return makeDeepCopy(individualParticipant, convertExtensions, true);
         });
@@ -25885,7 +25894,7 @@ function modifyPersonRequests({
 
 /**
  *
- * @param {string[]} scheduleAttributes - attributes by which it is determined that a matchUp as a schedule
+ * @param {string[]} scheduleAttributes - attributes by which it is determined that a matchUp has a schedule
  * @param {boolean} ignoreMatchUpStatuses - array of matchUpStatuses to ignore; defaults to completed
  * @param {object} tournamentRecord - provided automatically by tournamentEngine
  * @param {string[]} scheduleDates - optional - array of schedule dates to be cleared; default is to clear all dates
@@ -25912,27 +25921,32 @@ function clearScheduledMatchUps$1({
 
   if (venueIds.length) scheduleAttributes.push('venueId');
   const {
-    matchUps
+    matchUps: inContextMatchUps
   } = allTournamentMatchUps({
     matchUpFilters: {
       scheduledDates
     },
     tournamentRecord
   });
-  const relevantMatchUpIds = matchUps.filter(matchUp => !ignoreMatchUpStatuses.includes(matchUp.matchUpStatus) && hasSchedule({
+  const relevantMatchUpIds = inContextMatchUps.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);
-  const clearedScheduleValues = {
-    venueId: '',
-    scheduledDate: '',
-    scheduledTime: ''
-  };
-  return bulkScheduleMatchUps$1({
-    schedule: clearedScheduleValues,
-    matchUpIds: relevantMatchUpIds,
-    tournamentRecord
+  const {
+    matchUps
+  } = allTournamentMatchUps({
+    tournamentRecord,
+    inContext: false
   });
+
+  for (const matchUp of matchUps) {
+    if (relevantMatchUpIds.includes(matchUp.matchUpId)) {
+      matchUp.timeItems = (matchUp.timeItems || []).filter(timeItem => ![ASSIGN_COURT, ASSIGN_VENUE, SCHEDULED_DATE, SCHEDULED_TIME].includes(timeItem === null || timeItem === void 0 ? void 0 : timeItem.itemType));
+    }
+  }
+
+  return { ...SUCCESS
+  };
 }
 
 /**
@@ -29243,27 +29257,27 @@ function setTournamentRecord(record, deepCopyOption = true) {
   if (typeof record !== 'object' || Array.isArray(record)) return {
     error: INVALID_OBJECT
   };
-  if (!record.tournamentId) return {
+  if (!(record !== null && record !== void 0 && record.tournamentId)) return {
     error: INVALID_VALUES
   };
   return setTournamentRecord$1(deepCopyOption ? makeDeepCopy(record) : record);
 }
 function setState$3(records, deepCopyOption = true) {
+  var _records;
+
   if (typeof records !== 'object') return {
     error: INVALID_OBJECT
   };
 
   if (Array.isArray(records)) {
-    const validRecordsArray = records.filter(({
-      tournamentId
-    }) => tournamentId).length === records.length;
+    const validRecordsArray = records.filter(record => record === null || record === void 0 ? void 0 : record.tournamentId).length === records.length;
     if (!validRecordsArray) return {
       error: INVALID_RECORDS
     };
     records = Object.assign({}, ...records.map(record => ({
       [record.tournamentId]: record
     })));
-  } else if (records.tournamentId) {
+  } else if ((_records = records) !== null && _records !== void 0 && _records.tournamentId) {
     records = {
       [records.tournamentId]: records
     };
@@ -37497,7 +37511,7 @@ function getSideRatings({
       var _tournamentParticipan;
 
       const individualParticipantIds = tournamentParticipants === null || tournamentParticipants === void 0 ? void 0 : (_tournamentParticipan = tournamentParticipants.find(participant => participant.participantId === participantId)) === null || _tournamentParticipan === void 0 ? void 0 : _tournamentParticipan.individualParticipantIds;
-      return !individualParticipantIds ? DEFAULT_RATING * 2 : individualParticipantIds.map(participantId => adHocRatings[participantId || DEFAULT_RATING]);
+      return !individualParticipantIds ? DEFAULT_RATING * 2 : individualParticipantIds === null || individualParticipantIds === void 0 ? void 0 : individualParticipantIds.map(participantId => adHocRatings[participantId || DEFAULT_RATING]);
     } else {
       return adHocRatings[participantId] || DEFAULT_RATING;
     }
@@ -38382,15 +38396,17 @@ function getValidAlternatesAction({
 
   if (activeDrawPositions.includes(drawPosition)) return {};
   const otherFlightEntries = policyDefinitions === null || policyDefinitions === void 0 ? void 0 : (_policyDefinitions$PO = policyDefinitions[POLICY_TYPE_POSITION_ACTIONS]) === null || _policyDefinitions$PO === void 0 ? void 0 : _policyDefinitions$PO.otherFlightEntries;
-  const drawEnteredParticpantIds = (drawDefinition.entries || []).map(({
+  const drawEnteredParticpantIds = (drawDefinition.entries || []).sort((a, b) => (a.entryPosition || 9999) - (b.entryPosition || 9999)).map(({
     participantId
   }) => participantId).filter(Boolean);
   const assignedParticipantIds = positionAssignments.map(assignment => assignment.participantId).filter(Boolean);
+  const availableDrawEnteredParticipantIds = drawEnteredParticpantIds.filter(participantId => !assignedParticipantIds.includes(participantId));
   const eventEntries = event.entries || [];
-  const availableAlternatesParticipantIds = eventEntries.filter(entry => entry.entryStatus === ALTERNATE && eligibleEntryStage({
+  const availableEventAlternatesParticipantIds = eventEntries.filter(entry => entry.entryStatus === ALTERNATE && eligibleEntryStage({
     structure,
     entry
   }) && !assignedParticipantIds.includes(entry.participantId)).sort((a, b) => (a.entryPosition || 9999) - (b.entryPosition || 9999)).map(entry => entry.participantId);
+  const availableAlternatesParticipantIds = unique(availableDrawEnteredParticipantIds.concat(availableEventAlternatesParticipantIds));
 
   if (otherFlightEntries) {
     var _flightProfile$flight;
@@ -38400,7 +38416,7 @@ function getValidAlternatesAction({
     } = getFlightProfile({
       event
     });
-    const otherFlightEnteredParticipantIds = flightProfile === null || flightProfile === void 0 ? void 0 : (_flightProfile$flight = flightProfile.flights) === null || _flightProfile$flight === void 0 ? void 0 : _flightProfile$flight.filter(flight => flight.drawId !== drawId).map(flight => flight.drawEntries.filter(entry => entry.participantId && !drawEnteredParticpantIds.includes(entry.participantId)).map(({
+    const otherFlightEnteredParticipantIds = flightProfile === null || flightProfile === void 0 ? void 0 : (_flightProfile$flight = flightProfile.flights) === null || _flightProfile$flight === void 0 ? void 0 : _flightProfile$flight.filter(flight => flight.drawId !== drawId).map(flight => flight.drawEntries.filter(entry => entry.participantId && ![WITHDRAWN, UNGROUPED, UNPAIRED].includes(entry.entryStatus) && !drawEnteredParticpantIds.includes(entry.participantId)).map(({
       participantId
     }) => participantId)).flat().filter(Boolean);
 
@@ -40276,8 +40292,8 @@ function addParticipantScaleItem({
   const {
     scaleItem: existingScaleItem
   } = participantScaleItem({
-    participant,
-    scaleAttributes: scaleItem
+    scaleAttributes: scaleItem,
+    participant
   });
 
   const isUndefined = value => [undefined, null, ''].includes(value);
@@ -40292,10 +40308,10 @@ function addParticipantScaleItem({
     } = scaleItem;
     const itemType = [SCALE, scaleType, eventType, scaleName].join('.');
     const timeItem = {
-      itemType,
       itemValue: scaleItem.scaleValue,
       itemDate: scaleItem.scaleDate,
-      createdAt
+      createdAt,
+      itemType
     }; // if there is a unique identifier for the scale
 
     if (scaleItem.scaleId) {
@@ -44943,6 +44959,166 @@ function getScaledEntries({
   }
 }
 
+function prepareStage({
+  inContextDrawMatchUps,
+  matchUpsMap,
+  participants,
+  tournamentRecord,
+  drawDefinition,
+  automated,
+  drawType,
+  drawSize,
+  entries,
+  event,
+  enforcePolicyLimits = true,
+  seedAssignmentProfile,
+  // mainly used by mocksEngine for scenario testing
+  seedByRanking = true,
+  seededParticipants,
+  assignSeedsCount,
+  // used for testing bye placement next to seeds
+  seedingScaleName,
+  seedsCount,
+  stageSequence = 1,
+  stage
+}) {
+  const eventType = event === null || event === void 0 ? void 0 : event.eventType;
+  const stageEntries = entries.filter(entry => (!entry.entryStage || entry.entryStage === stage) && STRUCTURE_SELECTED_STATUSES.includes(entry.entryStatus));
+  if (seededParticipants) seedsCount = seededParticipants.length;
+  if (seedsCount > drawSize) seedsCount = drawSize;
+  if (seedsCount > stageEntries.length) seedsCount = stageEntries.length;
+  const {
+    structures
+  } = getDrawStructures({
+    drawDefinition,
+    stageSequence,
+    stage
+  });
+  const [structure] = structures;
+  const {
+    structureId
+  } = structure || {};
+  const {
+    seedLimit
+  } = initializeStructureSeedAssignments({
+    participantCount: stageEntries.length,
+    enforcePolicyLimits,
+    tournamentRecord,
+    drawDefinition,
+    structureId,
+    seedsCount,
+    event
+  });
+  if (seedLimit && seedLimit < seedsCount) seedsCount = seedLimit;
+  const enteredParticipantIds = entries.map(getParticipantId);
+
+  if (seededParticipants) {
+    seededParticipants.filter(({
+      participantId
+    }) => enteredParticipantIds.includes(participantId)).filter(seededParticipant => !seededParticipant.seedNumber || seededParticipant.seedNumber <= seededParticipants.length).sort((a, b) => {
+      if (a.seedNumber < b.seedNumber) return -1;
+      if (a.seedNumber < b.seedNumber) return 1;
+      return 0;
+    }).forEach(seededParticipant => {
+      const {
+        participantId,
+        seedNumber,
+        seedValue
+      } = seededParticipant;
+      assignSeed({
+        drawDefinition,
+        participantId,
+        structureId,
+        seedNumber,
+        seedValue
+      });
+    });
+  } else if (event !== null && event !== void 0 && event.category || seedingScaleName) {
+    var _scaledEntries, _scaledEntries2;
+
+    // if no seededParticipants have been defined, seed by seeding scale or ranking scale, if present
+    const {
+      categoryName,
+      ageCategoryCode
+    } = (event === null || event === void 0 ? void 0 : event.category) || {};
+    const seedingScaleAttributes = {
+      scaleType: SEEDING,
+      scaleName: seedingScaleName || categoryName || ageCategoryCode,
+      eventType
+    };
+    let {
+      scaledEntries
+    } = getScaledEntries({
+      scaleAttributes: seedingScaleAttributes,
+      tournamentRecord,
+      entries,
+      stage
+    });
+
+    if (!((_scaledEntries = scaledEntries) !== null && _scaledEntries !== void 0 && _scaledEntries.length) && seedByRanking) {
+      const rankingScaleAttributes = {
+        scaleType: RANKING,
+        scaleName: categoryName || ageCategoryCode,
+        eventType
+      };
+      ({
+        scaledEntries
+      } = getScaledEntries({
+        scaleAttributes: rankingScaleAttributes,
+        tournamentRecord,
+        entries,
+        stage
+      }));
+    }
+
+    const scaledEntriesCount = ((_scaledEntries2 = scaledEntries) === null || _scaledEntries2 === void 0 ? void 0 : _scaledEntries2.length) || 0;
+    if (scaledEntriesCount < seedsCount) seedsCount = scaledEntriesCount;
+    scaledEntries && scaledEntries.filter(({
+      participantId
+    }) => enteredParticipantIds.includes(participantId)).slice(0, assignSeedsCount || seedsCount).forEach((scaledEntry, index) => {
+      const seedNumber = index + 1;
+      const seedValue = (seedAssignmentProfile === null || seedAssignmentProfile === void 0 ? void 0 : seedAssignmentProfile[seedNumber]) || seedNumber; // ?? attach basis of seeding information to seedAssignment ??
+
+      const {
+        participantId
+      } = scaledEntry;
+      assignSeed({
+        drawDefinition,
+        participantId,
+        structureId,
+        seedNumber,
+        seedValue
+      });
+    });
+  }
+
+  let conflicts = [];
+
+  if (automated !== false) {
+    const seedsOnly = typeof automated === 'object' && automated.seedsOnly; // if { seedsOnly: true } then only seeds and an Byes releated to seeded positions are placed
+
+    ({
+      conflicts
+    } = automatedPositioning$1({
+      inContextDrawMatchUps,
+      drawDefinition,
+      participants,
+      structureId,
+      matchUpsMap,
+      seedsOnly,
+      drawType,
+      event
+    }));
+  }
+
+  return {
+    conflicts,
+    structureId,
+    seedsCount,
+    stageEntries
+  };
+}
+
 /**
  * automated = true, // can be true/false or "truthy" { seedsOnly: true }
  */
@@ -44950,52 +45126,30 @@ function getScaledEntries({
 function generateDrawDefinition(params) {
   const {
     drawType = SINGLE_ELIMINATION,
-    enforcePolicyLimits = true,
-    finishingPositionNaming,
     ignoreAllowedDrawTypes,
-    seedAssignmentProfile,
-    // mainly used by mocksEngine for scenario testing
-    playoffMatchUpFormat,
-    seedByRanking = true,
-    qualifyingProfiles,
-    seededParticipants,
     policyDefinitions,
-    seedingScaleName,
-    assignSeedsCount,
-    // used for testing bye placement next to seeds
-    automated = true,
-    seedingProfile,
+    tournamentRecord,
     tieFormatName,
     drawEntries,
-    feedPolicy,
-    idPrefix,
     drawId,
-    isMock,
-    uuids
-  } = params;
-  const {
-    tournamentRecord,
     event
-  } = params;
-  let {
-    drawName,
-    matchUpType,
-    structureOptions
-  } = params;
+  } = params; // get participants both for entry validation and for automated placement
+  // automated placement requires them to be "inContext" for avoidance policies to work
+
   const {
     tournamentParticipants: participants
   } = getTournamentParticipants({
     tournamentRecord,
     inContext: true
-  });
-  const validEntriesTest = event && participants && checkValidEntries({
+  }); // entries participantTypes must correspond with eventType
+  // this is only possible if the event is provided
+
+  const validEntriesResult = event && participants && checkValidEntries({
     event,
     participants
   });
-
-  if (validEntriesTest !== null && validEntriesTest !== void 0 && validEntriesTest.error) {
-    return validEntriesTest;
-  }
+  if (validEntriesResult !== null && validEntriesResult !== void 0 && validEntriesResult.error) return validEntriesResult; // if tournamentRecord is provided, and unless instructed to ignore valid types,
+  // check for restrictions on allowed drawTypes
 
   const allowedDrawTypes = !ignoreAllowedDrawTypes && tournamentRecord && getAllowedDrawTypes({
     tournamentRecord,
@@ -45007,19 +45161,18 @@ function generateDrawDefinition(params) {
     return {
       error: INVALID_DRAW_TYPE
     };
-  }
+  } // coersion of drawSize and seedsCount to integers
+
+
+  let drawSize = typeof params.drawSize !== 'number' ? parseInt(params.drawSize || 32) : params.drawSize || 32;
+  let seedsCount = typeof params.seedsCount !== 'number' ? parseInt(params.seedsCount || 0) : params.seedsCount || 0;
+  const eventType = event === null || event === void 0 ? void 0 : event.eventType;
+  const matchUpType = params.matchUpType || eventType; // drawDefinition cannot have both tieFormat and matchUpFormat
 
   let {
-    seedsCount,
-    drawSize = 32,
     tieFormat,
     matchUpFormat
-  } = params; // coersion
-
-  if (typeof drawSize !== 'number') drawSize = parseInt(drawSize);
-  if (typeof seedsCount !== 'number') seedsCount = parseInt(seedsCount || 0);
-  const eventType = event === null || event === void 0 ? void 0 : event.eventType;
-  matchUpType = matchUpType || eventType;
+  } = params;
 
   if (matchUpType === TEAM$3 && eventType === TEAM$3) {
     tieFormat = tieFormat || event !== null && event !== void 0 && event.tieFormat || tieFormatName ? typeof tieFormat === 'object' ? tieFormat : tieFormatName ? tieFormatDefaults({
@@ -45029,19 +45182,15 @@ function generateDrawDefinition(params) {
   } else if (!matchUpFormat) {
     tieFormat = undefined;
     matchUpFormat = 'SET3-S:6/TB7';
-  }
+  } // ---------------------------------------------------------------------------
+  // Begin construction of drawDefinition
 
-  const entries = drawEntries || (event === null || event === void 0 ? void 0 : event.entries) || [];
-  const stageEntries = entries.filter(entry => (!entry.entryStage || entry.entryStage === MAIN) && STRUCTURE_SELECTED_STATUSES.includes(entry.entryStatus)); // the reason for this needs to be clarified
-
-  if ([ROUND_ROBIN].includes(drawType)) {
-    drawSize = stageEntries.length || drawSize;
-  }
 
   const drawDefinition = newDrawDefinition({
     drawType,
     drawId
-  });
+  }); // if there is a defined matchUpFormat/tieFormat only attach to drawDefinition...
+  // ...when there is not an equivalent definition on the parent event
 
   if (matchUpFormat || tieFormat) {
     let equivalentInScope = matchUpFormat && (event === null || event === void 0 ? void 0 : event.matchUpFormat) === matchUpFormat || (event === null || event === void 0 ? void 0 : event.tieFormat) && tieFormat && JSON.stringify(event.tieFormat) === JSON.stringify(tieFormat); // if an equivalent matchUpFormat or tieFormat is attached to the event
@@ -45065,52 +45214,22 @@ function generateDrawDefinition(params) {
     }
   }
 
-  tieFormat = tieFormat || (event === null || event === void 0 ? void 0 : event.tieFormat);
-  let result = generateDrawType({
-    finishingPositionNaming,
-    goesTo: params.goesTo,
-    playoffMatchUpFormat,
-    qualifyingProfiles,
-    structureOptions,
+  let drawTypeResult = generateDrawType({ ...params,
     drawDefinition,
-    seedingProfile,
     matchUpFormat,
     matchUpType,
-    feedPolicy,
     tieFormat,
-    drawSize,
-    drawType,
-    idPrefix,
-    isMock,
-    uuids
-  });
-  if (result.error) return result;
-  const {
-    matchUpsMap,
-    inContextDrawMatchUps
-  } = result;
-  const {
-    structures
-  } = getDrawStructures({
-    drawDefinition,
-    stageSequence: 1,
-    stage: MAIN
+    drawSize
   });
-  const [structure] = structures;
-  const {
-    structureId
-  } = structure || {};
+  if (drawTypeResult.error) return drawTypeResult; // first attach any policyDefinitions which have been provided
 
   if (typeof policyDefinitions === 'object') {
-    for (const policyType of Object.keys(policyDefinitions)) {
-      attachPolicies({
-        policyDefinitions: {
-          [policyType]: policyDefinitions[policyType]
-        },
-        drawDefinition
-      });
-    }
-  }
+    attachPolicies({
+      policyDefinitions,
+      drawDefinition
+    });
+  } // then check for a seedingPolicy at all levels
+
 
   const {
     policyDefinitions: seedingPolicy
@@ -45119,9 +45238,10 @@ function generateDrawDefinition(params) {
     tournamentRecord,
     drawDefinition,
     event
-  }) || {};
+  }) || {}; // if no seeding policy provided and none present at any other level, attach default
+  // this needs to be attached for prepareStage => initializeSeedAssignments
 
-  if (!(policyDefinitions !== null && policyDefinitions !== void 0 && policyDefinitions[POLICY_TYPE_SEEDING]) && !(seedingPolicy !== null && seedingPolicy !== void 0 && seedingPolicy[POLICY_TYPE_SEEDING])) {
+  if (!(seedingPolicy !== null && seedingPolicy !== void 0 && seedingPolicy[POLICY_TYPE_SEEDING])) {
     // if there is no seeding policy then use default seeing policy
     attachPolicies({
       drawDefinition,
@@ -45146,7 +45266,11 @@ function generateDrawDefinition(params) {
       drawDefinition,
       policyDefinitions: eventAvoidancePolicy
     });
-  }
+  } // add all entries to the draw
+  // TODO: if there are no qualifyingProfiles, skip adding qualifying entries
+
+
+  const entries = drawEntries || (event === null || event === void 0 ? void 0 : event.entries) || [];
 
   for (const entry of entries) {
     // convenience: assume MAIN as entryStage if none provided
@@ -45161,153 +45285,56 @@ function generateDrawDefinition(params) {
       // if entries are taken from event.entries assume stageSpace is not available
       return result;
     }
-  }
+  } // temporary until seeding is supported in LUCKY_DRAW
 
-  const enteredParticipantIds = entries.map(getParticipantId);
-  if (seededParticipants) seedsCount = seededParticipants.length;
-  if (seedsCount > drawSize) seedsCount = drawSize;
-  if (seedsCount > stageEntries.length) seedsCount = stageEntries.length;
-  const {
-    seedLimit
-  } = initializeStructureSeedAssignments({
-    participantCount: stageEntries.length,
-    enforcePolicyLimits,
-    tournamentRecord,
+
+  if (drawType === LUCKY_DRAW) seedsCount = 0;
+  const structureResult = prepareStage({ ...drawTypeResult,
+    ...params,
     drawDefinition,
-    structureId,
+    participants,
+    stage: MAIN,
     seedsCount,
-    event
+    drawSize,
+    entries
   });
-  if (seedLimit && seedLimit < seedsCount) seedsCount = seedLimit; // temporary until seeding is supported in LUCKY_DRAW
 
-  if (drawType === LUCKY_DRAW) seedsCount = 0;
+  if (params.qualifyingProfiles) {
+    console.log(params.qualifyingProfiles);
+    let stageSequence = 1;
 
-  if (seededParticipants) {
-    seededParticipants.filter(({
-      participantId
-    }) => enteredParticipantIds.includes(participantId)).filter(seededParticipant => !seededParticipant.seedNumber || seededParticipant.seedNumber <= seededParticipants.length).sort((a, b) => {
-      if (a.seedNumber < b.seedNumber) return -1;
-      if (a.seedNumber < b.seedNumber) return 1;
-      return 0;
-    }).forEach(seededParticipant => {
+    for (const qualifyingProfile of params.qualifyingProfiles) {
       const {
-        participantId,
-        seedNumber,
-        seedValue
-      } = seededParticipant;
-      assignSeed({
+        drawSize,
+        qualifyingRoundNumber,
+        qualifyingPositions
+      } = qualifyingProfile;
+      const qualifyingResult = prepareStage({ ...drawTypeResult,
+        ...params,
+        qualifyingRoundNumber,
+        qualifyingPositions,
+        stage: QUALIFYING,
         drawDefinition,
-        participantId,
-        structureId,
-        seedNumber,
-        seedValue
-      });
-    });
-  } else if (event !== null && event !== void 0 && event.category || seedingScaleName) {
-    var _scaledEntries, _scaledEntries2;
-
-    // if no seededParticipants have been defined, seed by seeding scale or ranking scale, if present
-    const {
-      categoryName,
-      ageCategoryCode
-    } = (event === null || event === void 0 ? void 0 : event.category) || {};
-    const seedingScaleAttributes = {
-      scaleType: SEEDING,
-      scaleName: seedingScaleName || categoryName || ageCategoryCode,
-      eventType
-    };
-    let {
-      scaledEntries
-    } = getScaledEntries({
-      scaleAttributes: seedingScaleAttributes,
-      tournamentRecord,
-      stage: MAIN,
-      entries
-    });
-
-    if (!((_scaledEntries = scaledEntries) !== null && _scaledEntries !== void 0 && _scaledEntries.length) && seedByRanking) {
-      const rankingScaleAttributes = {
-        scaleType: RANKING,
-        scaleName: categoryName || ageCategoryCode,
-        eventType
-      };
-      ({
-        scaledEntries
-      } = getScaledEntries({
-        scaleAttributes: rankingScaleAttributes,
-        tournamentRecord,
-        stage: MAIN,
+        stageSequence,
+        seedsCount: 0,
+        participants,
+        drawSize,
         entries
-      }));
-    }
-
-    const scaledEntriesCount = ((_scaledEntries2 = scaledEntries) === null || _scaledEntries2 === void 0 ? void 0 : _scaledEntries2.length) || 0;
-    if (scaledEntriesCount < seedsCount) seedsCount = scaledEntriesCount;
-    scaledEntries && scaledEntries.filter(({
-      participantId
-    }) => enteredParticipantIds.includes(participantId)).slice(0, assignSeedsCount || seedsCount).forEach((scaledEntry, index) => {
-      const seedNumber = index + 1;
-      const seedValue = (seedAssignmentProfile === null || seedAssignmentProfile === void 0 ? void 0 : seedAssignmentProfile[seedNumber]) || seedNumber; // ?? attach basis of seeding information to seedAssignment ??
-
-      const {
-        participantId
-      } = scaledEntry;
-      assignSeed({
-        drawDefinition,
-        participantId,
-        structureId,
-        seedNumber,
-        seedValue
       });
-    });
-  }
-
-  let conflicts = [];
-
-  if (automated !== false) {
-    const seedsOnly = typeof automated === 'object' && automated.seedsOnly; // if { seedsOnly: true } then only seeds and an Byes releated to seeded positions are placed
-
-    ({
-      conflicts
-    } = automatedPositioning$1({
-      inContextDrawMatchUps,
-      drawDefinition,
-      participants,
-      structureId,
-      matchUpsMap,
-      seedsOnly,
-      drawType,
-      event
-    }));
+      stageSequence += 1;
+      console.log({
+        qualifyingResult
+      });
+    }
   }
 
-  drawName = drawName || drawType;
-  if (drawDefinition) Object.assign(drawDefinition, {
-    drawName
-  });
-  const drawDetails = {
-    drawId: drawDefinition.drawId,
-    category: event === null || event === void 0 ? void 0 : event.category,
-    eventId: event === null || event === void 0 ? void 0 : event.eventId,
-    seedingScaleName,
-    matchUpType,
-    seedsCount,
-    automated,
-    tieFormat,
-    drawSize,
-    drawType,
-    drawName
-  };
-  addNotice({
-    topic: AUDIT,
-    payload: {
-      action: 'generateDrawDefinition',
-      payload: drawDetails
-    }
-  });
-  return { ...SUCCESS,
-    structureId,
+  const conflicts = structureResult.conflicts;
+  const structureId = structureResult.structureId;
+  drawDefinition.drawName = params.drawName || drawType;
+  return {
     drawDefinition,
+    structureId,
+    ...SUCCESS,
     conflicts
   };
 }
@@ -52327,12 +52354,22 @@ function generateEventWithDraw({
     stage
   } = drawProfile;
   const eventType = drawProfile.eventType || drawProfile.matchUpType || SINGLES;
+  const participantType = eventType === DOUBLES ? PAIR$1 : INDIVIDUAL$1;
   const tieFormat = typeof drawProfile.tieFormat === 'object' ? drawProfile.tieFormat : eventType === TEAM$1 ? tieFormatDefaults({
     namedFormat: tieFormatName
   }) : undefined;
   const categoryName = (category === null || category === void 0 ? void 0 : category.categoryName) || (category === null || category === void 0 ? void 0 : category.ageCategoryCode) || (category === null || category === void 0 ? void 0 : category.ratingType);
   let eventName = drawProfile.eventName || categoryName || `Generated ${eventType}`;
   let targetParticipants = (tournamentRecord === null || tournamentRecord === void 0 ? void 0 : tournamentRecord.participants) || [];
+  /*
+  const qualifyingIndividualParticipantsCount =
+    (params.qualifyingProfiles?.reduce(
+      (count, profile) => count + profile.drawSize,
+      0
+    ) || 0) * (participantType === DOUBLES ? 2 : 1);
+  console.log({ qualifyingIndividualParticipantsCount });
+  */
+
   const participantsCount = !drawProfile.participantsCount || drawProfile.participantsCount > drawSize ? drawSize : drawProfile.participantsCount;
   const eventId = UUID();
   let event = {
@@ -52374,7 +52411,6 @@ function generateEventWithDraw({
     }
 
     const idPrefix = participantsProfile !== null && participantsProfile !== void 0 && participantsProfile.idPrefix ? `D-${drawIndex}-${participantsProfile === null || participantsProfile === void 0 ? void 0 : participantsProfile.idPrefix}` : undefined;
-    const participantType = eventType === DOUBLES ? PAIR$1 : INDIVIDUAL$1;
     const {
       participants: unique
     } = generateParticipants({ ...participantsProfile,