tods-competition-factory 0.64.2 → 0.66.0

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

@@ -248,6 +248,10 @@ const matchUpFormatCode = {
   parse
 };
 
+function factoryVersion() {
+  return '0.66.0';
+}
+
 const FORMAT_STANDARD = 'SET3-S:6/TB7'; // Best of 3 Tiebreak Sets to 6
 
 const FORMAT_STANDARD_NOAD = 'SET3-S:6NOAD'; // Best of 3 NOAD Sets to 6 with deciding game at 5-5
@@ -9451,7 +9455,9 @@ function getRoundMatchUps$1({
     const currentRoundMatchUps = roundMatchUps[roundNumber].sort((a, b) => a.roundPosition - b.roundPosition);
     const currentRoundDrawPositions = currentRoundMatchUps.map(matchUp => (matchUp === null || matchUp === void 0 ? void 0 : matchUp.drawPositions) || []).flat();
     roundProfile[roundNumber].roundNumber = roundNumber; // convenience
+    // convenience for display calculations
 
+    roundProfile[roundNumber].roundFactor = roundProfile[roundNumber].matchUpsCount ? maxMatchUpsCount / roundProfile[roundNumber].matchUpsCount : 1;
     roundProfile[roundNumber].finishingRound = finishingRoundMap[roundNumber].finishingRound;
     roundProfile[roundNumber].roundName = finishingRoundMap[roundNumber].roundName;
     roundProfile[roundNumber].abbreviatedRoundName = finishingRoundMap[roundNumber].abbreviatedRoundName;
@@ -11375,7 +11381,7 @@ function getAllStructureMatchUps({
     matchUp,
     event
   }) {
-    var _roundNamingProfile$r, _roundNamingProfile$r2;
+    var _roundNamingProfile$r, _roundNamingProfile$r2, _roundProfile$roundNu, _roundProfile$roundNu2, _roundProfile$roundNu3;
 
     const tieFormat = matchUp.tieFormat || structure.tieFormat || (drawDefinition === null || drawDefinition === void 0 ? void 0 : drawDefinition.tieFormat) || (event === null || event === void 0 ? void 0 : event.tieFormat);
     const collectionDefinitions = tieFormat === null || tieFormat === void 0 ? void 0 : tieFormat.collectionDefinitions;
@@ -11415,7 +11421,9 @@ function getAllStructureMatchUps({
     });
     const roundName = roundNamingProfile && ((_roundNamingProfile$r = roundNamingProfile[roundNumber]) === null || _roundNamingProfile$r === void 0 ? void 0 : _roundNamingProfile$r.roundName) || additionalContext.roundName;
     const abbreviatedRoundName = roundNamingProfile && ((_roundNamingProfile$r2 = roundNamingProfile[roundNumber]) === null || _roundNamingProfile$r2 === void 0 ? void 0 : _roundNamingProfile$r2.abbreviatedRoundName) || additionalContext.abbreviatedRoundName;
-    const feedRound = roundProfile && roundProfile[roundNumber] && roundProfile[roundNumber].feedRound;
+    const feedRound = roundProfile === null || roundProfile === void 0 ? void 0 : (_roundProfile$roundNu = roundProfile[roundNumber]) === null || _roundProfile$roundNu === void 0 ? void 0 : _roundProfile$roundNu.feedRound;
+    const preFeedRound = roundProfile === null || roundProfile === void 0 ? void 0 : (_roundProfile$roundNu2 = roundProfile[roundNumber]) === null || _roundProfile$roundNu2 === void 0 ? void 0 : _roundProfile$roundNu2.preFeedRound;
+    const roundFactor = roundProfile === null || roundProfile === void 0 ? void 0 : (_roundProfile$roundNu3 = roundProfile[roundNumber]) === null || _roundProfile$roundNu3 === void 0 ? void 0 : _roundProfile$roundNu3.roundFactor;
     const drawPositionsRoundRanges = drawPositionsRanges && drawPositionsRanges[roundNumber];
     const drawPositionsRange = drawPositionsRoundRanges && drawPositionsRoundRanges[roundPosition];
     const sourceDrawPositionRoundRanges = sourceDrawPositionRanges && sourceDrawPositionRanges[roundNumber]; // order is important here as Round Robin matchUps already have inContext structureId
@@ -11433,6 +11441,8 @@ function getAllStructureMatchUps({
       drawPositions,
       matchUpStatus,
       matchUpTieId,
+      preFeedRound,
+      roundFactor,
       matchUpType,
       exitProfile,
       structureId,
@@ -13032,7 +13042,7 @@ function addUpcomingMatchUps({
         }
 
         if ((_loserTo = loserTo) !== null && _loserTo !== void 0 && (_loserTo$schedule = _loserTo.schedule) !== null && _loserTo$schedule !== void 0 && _loserTo$schedule.scheduledTime) {
-          const scheduleConflict = timeStringMinutes(winnerTo.schedule.scheduledTime) < timeStringMinutes(timeAfterRecovery);
+          const scheduleConflict = timeStringMinutes(loserTo.schedule.scheduledTime) < timeStringMinutes(timeAfterRecovery);
 
           if (scheduleConflict) {
             scheduleConflictMatchUpIds[loserTo.matchUpId] = inContextMatchUp.matchUpId;
@@ -18057,9 +18067,9 @@ function getAvailableAdHocParticipantIds({
     drawPosition,
     participantId
   }) => roundDrawPositions.includes(drawPosition) && participantId).map(getParticipantId);
-  const enteredParticipantIds = drawDefinition.entries.filter(({
+  const enteredParticipantIds = (drawDefinition === null || drawDefinition === void 0 ? void 0 : drawDefinition.entries.filter(({
     entryStatus
-  }) => [DIRECT_ACCEPTANCE, ORGANISER_ACCEPTANCE, WILDCARD].includes(entryStatus)).map(getParticipantId); // AdHoc available participants are those entered in the draw who are not assigned to the target round
+  }) => [DIRECT_ACCEPTANCE, ORGANISER_ACCEPTANCE, WILDCARD].includes(entryStatus)).map(getParticipantId)) || []; // AdHoc available participants are those entered in the draw who are not assigned to the target round
 
   const availableParticipantIds = enteredParticipantIds.filter(participantId => !roundAssignedParticipantIds.includes(participantId));
   return availableParticipantIds;
@@ -28039,10 +28049,6 @@ const scheduleGovernor$1 = {
   removePersonRequests
 };
 
-function factoryVersion() {
-  return '0.64.2';
-}
-
 function attachPolicies$2({
   tournamentRecord,
   policyDefinitions,
@@ -34633,7 +34639,7 @@ function getAssignedParticipantIds({
 function refreshEntryPositions({
   entries = []
 } = {}) {
-  const stagedEntries = entries.reduce((stages, entry) => {
+  const stagedEntries = entries.filter(Boolean).reduce((stages, entry) => {
     const {
       entryStage,
       entryStatus
@@ -34845,6 +34851,8 @@ function modifyEntriesStatus({
         return true;
       });
       (_event$drawDefinition4 = event.drawDefinitions) === null || _event$drawDefinition4 === void 0 ? void 0 : _event$drawDefinition4.every(drawDefinition => {
+        var _drawDefinition$entri2;
+
         const result = updateEntryStatus(drawDefinition.entries);
 
         if (result.error) {
@@ -34852,7 +34860,7 @@ function modifyEntriesStatus({
           return false;
         }
 
-        drawDefinition.entries = drawDefinition.entries.filter(({
+        drawDefinition.entries = (_drawDefinition$entri2 = drawDefinition.entries) === null || _drawDefinition$entri2 === void 0 ? void 0 : _drawDefinition$entri2.filter(({
           participantId
         }) => !participantIds.includes(participantId));
         return true;
@@ -35189,8 +35197,8 @@ function participantInEntries({
 function addDrawEntry({
   entryStatus = DIRECT_ACCEPTANCE,
   entryStage = MAIN,
-  entryPosition,
   drawDefinition,
+  entryPosition,
   participantId,
   participant
 }) {
@@ -35222,7 +35230,7 @@ function addDrawEntry({
     };
   }
 
-  participantId = participantId || participant && participant.participantId;
+  participantId = participantId || (participant === null || participant === void 0 ? void 0 : participant.participantId);
   if (!participantId) return {
     error: MISSING_PARTICIPANT_ID
   };
@@ -35344,7 +35352,7 @@ function addDrawEntries$1({
     };
   }
 
-  participantIds.forEach(participantId => {
+  participantIds.filter(Boolean).forEach(participantId => {
     const entry = Object.assign({
       participantId
     }, {
@@ -36439,6 +36447,7 @@ function generateDrawMaticRound({
   const {
     participantIdPairings
   } = eventType === DOUBLES ? getDoublesPairings(params) : getSinglesPairings(params);
+  console.log(participantIdPairings);
 
   for (const [index, matchUp] of roundMatchUps.entries()) {
     const drawPositions = matchUp.drawPositions;
@@ -36599,13 +36608,16 @@ function drawMatic$1({
   matchUpIds,
   scaleName,
   // custom rating name to seed dynamic ratings
-  eventType
+  event
 }) {
   var _drawDefinition$struc2;
 
   if (typeof drawDefinition !== 'object') return {
     error: INVALID_DRAW_DEFINITION
   };
+  const {
+    eventType
+  } = event || {};
   const enteredParticipantIds = drawDefinition.entries.filter(({
     entryStatus
   }) => !restrictEntryStatus || [DIRECT_ACCEPTANCE, ORGANISER_ACCEPTANCE, WILDCARD].includes(entryStatus)).map(getParticipantId);
@@ -50143,6 +50155,7 @@ function generateParticipants({
   participantsCount = 32,
   participantType,
   personIds,
+  idPrefix,
   uuids,
   personExtensions,
   addressProps,
@@ -50272,12 +50285,18 @@ function generateParticipants({
     });
     const individualParticipantIds = individualParticipants.map(participant => participant.participantId);
     const pairName = individualParticipants.map(i => i.person.standardFamilyName).join('/');
+    const participantType = doubles ? PAIR$1 : TEAM$1;
     const groupParticipant = {
-      participantId: (uuids === null || uuids === void 0 ? void 0 : uuids.pop()) || UUID(),
-      participantType: doubles ? PAIR$1 : TEAM$1,
+      participantId: genParticipantId({
+        participantType,
+        idPrefix,
+        index: i,
+        uuids
+      }),
       participantRole: COMPETITOR,
       participantName: doubles ? pairName : teamNames[i],
-      individualParticipantIds
+      individualParticipantIds,
+      participantType
     };
     if (inContext) groupParticipant.individualParticipants = individualParticipants;
     return doubles || team ? [groupParticipant, ...individualParticipants] : individualParticipants;
@@ -50317,7 +50336,12 @@ function generateParticipants({
       nationalityCode
     });
     const participant = definedAttributes({
-      participantId: (uuids === null || uuids === void 0 ? void 0 : uuids.pop()) || UUID(),
+      participantId: genParticipantId({
+        participantType: INDIVIDUAL$1,
+        index: participantIndex,
+        idPrefix,
+        uuids
+      }),
       extensions: participantExtensions,
       timeItems: participantTimeItems,
       participantRole: COMPETITOR,
@@ -50402,6 +50426,16 @@ function addScaleItem({
   }
 }
 
+function genParticipantId({
+  idPrefix,
+  participantType,
+  index,
+  uuids
+}) {
+  const type = participantType === INDIVIDUAL$1 ? 'I' : 'P' ;
+  return idPrefix ? `${idPrefix}-${type}-${index}` : (uuids === null || uuids === void 0 ? void 0 : uuids.pop()) || UUID();
+}
+
 function processTieFormat({
   tieFormat,
   tieFormatName,
@@ -50572,7 +50606,7 @@ function getParticipantsCount({
 }
 
 function addTournamentParticipants({
-  participantsProfile,
+  participantsProfile = {},
   tournamentRecord,
   eventProfiles,
   drawProfiles,
@@ -50590,35 +50624,16 @@ function addTournamentParticipants({
     drawProfiles
   });
   const {
-    nationalityCodesCount,
-    nationalityCodeType,
-    valuesInstanceLimit,
-    nationalityCodes,
-    personExtensions,
-    addressProps,
-    personData,
-    personIds,
-    inContext,
-    teamKey,
-    sex
+    teamKey
   } = participantsProfile || {};
   const {
     participants
   } = generateParticipants({
+    uuids,
+    ...participantsProfile,
     consideredDate: startDate,
-    valuesInstanceLimit,
-    nationalityCodesCount,
-    nationalityCodeType,
-    nationalityCodes,
-    personExtensions,
-    addressProps,
-    personData,
-    sex,
     participantsCount,
-    participantType,
-    personIds,
-    uuids,
-    inContext
+    participantType
   });
   let result = addParticipants({
     tournamentRecord,
@@ -50655,11 +50670,12 @@ function addTournamentParticipants({
 }
 
 function generateEventParticipants({
+  participantsProfile = {},
   uniqueParticipantsCount,
-  participantsProfile,
   ratingsParameters,
   tournamentRecord,
   eventProfile,
+  eventIndex,
   event,
   uuids
 }) {
@@ -50668,38 +50684,25 @@ function generateEventParticipants({
     gender,
     eventType
   } = event;
-  const {
-    valuesInstanceLimit,
-    nationalityCodesCount,
-    nationalityCodeType,
-    nationalityCodes,
-    addressProps,
-    personIds,
-    inContext
-  } = participantsProfile || {};
   const eventParticipantType = eventType === SINGLES ? INDIVIDUAL$1 : eventType === DOUBLES ? PAIR$1 : eventType;
   const mainParticipantsCount = uniqueParticipantsCount[MAIN] || 0;
   const qualifyingParticipantsCount = uniqueParticipantsCount[QUALIFYING] || 0;
   const participantsCount = mainParticipantsCount + qualifyingParticipantsCount;
   const sex = [MALE, FEMALE].includes(gender) ? gender : undefined;
+  const idPrefix = participantsProfile !== null && participantsProfile !== void 0 && participantsProfile.idPrefix ? `E-${eventIndex}-${participantsProfile === null || participantsProfile === void 0 ? void 0 : participantsProfile.idPrefix}` : undefined;
   const {
     participants: uniqueFlightParticipants
   } = generateParticipants({
+    uuids: eventProfile.uuids || uuids,
+    ...participantsProfile,
     scaledParticipantsCount: eventProfile.scaledParticipantsCount,
     consideredDate: tournamentRecord === null || tournamentRecord === void 0 ? void 0 : tournamentRecord.startDate,
     rankingRange: eventProfile.rankingRange,
     participantType: eventParticipantType,
-    nationalityCodesCount,
-    nationalityCodeType,
-    valuesInstanceLimit,
     participantsCount,
     ratingsParameters,
-    nationalityCodes,
-    addressProps,
-    personIds,
-    inContext,
+    idPrefix,
     category,
-    uuids,
     sex
   });
   let result = addParticipants({
@@ -50868,222 +50871,6 @@ function generateFlights({
   };
 }
 
-function modifyTournamentRecord({
-  matchUpStatusProfile,
-  completeAllMatchUps,
-  participantsProfile,
-  autoEntryPositions,
-  randomWinningSide,
-  tournamentRecord,
-  eventProfiles,
-  uuids
-}) {
-  if (!tournamentRecord) return {
-    error: MISSING_TOURNAMENT_RECORD
-  };
-  const allUniqueParticipantIds = [];
-  const drawIds = [];
-  eventProfiles === null || eventProfiles === void 0 ? void 0 : eventProfiles.forEach(eventProfile => {
-    const event = tournamentRecord.events.find((event, index) => eventProfile.eventIndex !== undefined && index === eventProfile.eventIndex || eventProfile.eventName && event.eventName === eventProfile.eventName || eventProfile.eventId && event.eventId === eventProfile.eventId);
-
-    if (event !== null && event !== void 0 && event.gender) {
-      eventProfile.gender = event.gender;
-    }
-  });
-  const result = addTournamentParticipants({
-    startDate: tournamentRecord.startDate,
-    participantsProfile,
-    tournamentRecord,
-    eventProfiles,
-    // drawProfiles,
-    uuids
-  });
-  if (!result.success) return result;
-
-  if (eventProfiles) {
-    for (const eventProfile of eventProfiles) {
-      let {
-        ratingsParameters
-      } = eventProfile;
-      const event = tournamentRecord.events.find((event, index) => eventProfile.eventIndex !== undefined && index === eventProfile.eventIndex || eventProfile.eventName && event.eventName === eventProfile.eventName || eventProfile.eventId && event.eventId === eventProfile.eventId);
-      if (!event) return {
-        error: EVENT_NOT_FOUND
-      };
-      const {
-        gender,
-        category,
-        eventType
-      } = event;
-      const {
-        drawProfiles
-      } = eventProfile;
-      const eventParticipantType = eventType === SINGLES ? INDIVIDUAL : eventType === DOUBLES ? PAIR : eventType;
-
-      if (drawProfiles) {
-        const {
-          stageParticipantsCount,
-          uniqueParticipantsCount,
-          uniqueParticipantStages
-        } = getStageParticipantsCount({
-          drawProfiles,
-          category,
-          gender
-        });
-        const {
-          uniqueDrawParticipants = [],
-          uniqueParticipantIds = []
-        } = uniqueParticipantStages ? generateEventParticipants({
-          event: {
-            eventType,
-            category,
-            gender
-          },
-          uniqueParticipantsCount,
-          participantsProfile,
-          ratingsParameters,
-          tournamentRecord,
-          eventProfile,
-          uuids
-        }) : {};
-        allUniqueParticipantIds.push(...uniqueParticipantIds);
-        const {
-          stageParticipants
-        } = getStageParticipants({
-          targetParticipants: tournamentRecord.participants || [],
-          allUniqueParticipantIds,
-          stageParticipantsCount,
-          eventParticipantType
-        });
-        let result = generateFlights({
-          uniqueDrawParticipants,
-          autoEntryPositions,
-          stageParticipants,
-          tournamentRecord,
-          drawProfiles,
-          category,
-          gender,
-          event
-        });
-        if (result.error) return result;
-        result = generateFlightDrawDefinitions({
-          matchUpStatusProfile,
-          completeAllMatchUps,
-          randomWinningSide,
-          tournamentRecord,
-          drawProfiles,
-          event
-        });
-        if (result.error) return result;
-        drawIds.push(...result.drawIds);
-      }
-    }
-  }
-
-  return { ...SUCCESS,
-    drawIds
-  };
-}
-
-const amendsGovernor = {
-  anonymizeTournamentRecord,
-  modifyTournamentRecord
-};
-
-function generateSchedulingProfile({
-  schedulingProfile,
-  tournamentRecord
-}) {
-  if (typeof schedulingProfile !== 'object') return {
-    error: INVALID_VALUES
-  };
-  const containedStructures = getContainedStructures({
-    tournamentRecord
-  }).containedStructures;
-  const {
-    matchUps
-  } = allTournamentMatchUps({
-    tournamentRecord
-  });
-  const {
-    tournamentId
-  } = tournamentRecord;
-  const scheduledRounds = [];
-
-  for (const dateProfile of schedulingProfile) {
-    const {
-      scheduleDate,
-      venues = []
-    } = dateProfile;
-
-    for (const venue of venues) {
-      const {
-        rounds,
-        venueId
-      } = venue;
-
-      for (const round of rounds) {
-        const {
-          drawId,
-          winnerFinishingPositionRange,
-          roundSegment
-        } = round;
-        const targetMatchUps = matchUps.filter(matchUp => {
-          var _matchUp$finishingPos;
-
-          const targetRange = (winnerFinishingPositionRange === null || winnerFinishingPositionRange === void 0 ? void 0 : winnerFinishingPositionRange.indexOf('-')) > 0 && winnerFinishingPositionRange.split('-').map(x => +x);
-          const range = (_matchUp$finishingPos = matchUp.finishingPositionRange) === null || _matchUp$finishingPos === void 0 ? void 0 : _matchUp$finishingPos.winner;
-          const target = matchUp.drawId === drawId && (!round.roundNumber || matchUp.roundNumber === round.roundNumber) && (!range || !targetRange || intersection(range, targetRange).length === 2);
-          return target;
-        });
-        const targetMatchUp = targetMatchUps[0];
-
-        if (targetMatchUp) {
-          const {
-            eventId,
-            roundNumber,
-            drawName,
-            structureName,
-            roundName
-          } = targetMatchUp;
-          let structureId = targetMatchUp.structureId;
-
-          if (roundNumber && !winnerFinishingPositionRange) {
-            structureId = Object.keys(containedStructures).find(containingStructureId => containedStructures[containingStructureId].includes(structureId));
-          }
-
-          const roundToSchedule = {
-            tournamentId,
-            eventId,
-            drawId,
-            structureId,
-            roundNumber,
-            roundSegment
-          };
-          let result = addSchedulingProfileRound({
-            tournamentRecords: {
-              [tournamentId]: tournamentRecord
-            },
-            scheduleDate,
-            venueId,
-            round: roundToSchedule
-          });
-          if (result.error) return result;
-          scheduledRounds.push({
-            drawName,
-            structureName,
-            roundName,
-            ...roundToSchedule
-          });
-        }
-      }
-    }
-  }
-
-  return {
-    scheduledRounds
-  };
-}
-
 function generateEventWithFlights({
   allUniqueParticipantIds,
   matchUpStatusProfile,
@@ -51094,6 +50881,7 @@ function generateEventWithFlights({
   ratingsParameters,
   tournamentRecord,
   eventProfile,
+  eventIndex,
   uuids
 }) {
   let gender = eventProfile.gender;
@@ -51143,6 +50931,7 @@ function generateEventWithFlights({
     ratingsParameters,
     tournamentRecord,
     eventProfile,
+    eventIndex,
     uuids
   }) : {}; // Create event object -------------------------------------------------------
 
@@ -51231,8 +51020,8 @@ function generateEventWithFlights({
 
 function generateEventWithDraw({
   allUniqueParticipantIds = [],
+  participantsProfile = {},
   matchUpStatusProfile,
-  participantsProfile,
   completeAllMatchUps,
   autoEntryPositions,
   randomWinningSide,
@@ -51240,6 +51029,7 @@ function generateEventWithDraw({
   tournamentRecord,
   drawProfile,
   startDate,
+  drawIndex,
   goesTo,
   uuids
 }) {
@@ -51308,34 +51098,20 @@ function generateEventWithDraw({
       individualParticipantsCount = teamSize * drawSize;
     }
 
+    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 {
-      valuesInstanceLimit,
-      nationalityCodesCount,
-      nationalityCodeType,
-      nationalityCodes,
-      addressProps,
-      personIds,
-      inContext
-    } = participantsProfile || {};
     const {
       participants: unique
-    } = generateParticipants({
+    } = generateParticipants({ ...participantsProfile,
       scaledParticipantsCount: drawProfile.scaledParticipantsCount,
       participantsCount: individualParticipantsCount,
       consideredDate: tournamentRecord === null || tournamentRecord === void 0 ? void 0 : tournamentRecord.startDate,
       sex: gender || (participantsProfile === null || participantsProfile === void 0 ? void 0 : participantsProfile.sex),
       rankingRange: drawProfile.rankingRange,
       uuids: drawProfile.uuids || uuids,
-      nationalityCodesCount,
-      nationalityCodeType,
-      valuesInstanceLimit,
       ratingsParameters,
-      nationalityCodes,
       participantType,
-      addressProps,
-      personIds,
-      inContext,
+      idPrefix,
       category
     });
 
@@ -51648,6 +51424,340 @@ function generateVenues({
   return venueIds;
 }
 
+function modifyTournamentRecord({
+  ratingsParameters: ratingsParameters$1 = ratingsParameters,
+  participantsProfile = {},
+  matchUpStatusProfile,
+  completeAllMatchUps,
+  autoEntryPositions,
+  randomWinningSide,
+  schedulingProfile,
+  tournamentRecord,
+  eventProfiles,
+  venueProfiles,
+  autoSchedule,
+  drawProfiles,
+  goesTo,
+  uuids
+}) {
+  var _tournamentRecord$par;
+
+  if (!tournamentRecord) return {
+    error: MISSING_TOURNAMENT_RECORD
+  };
+  const allUniqueParticipantIds = [];
+  const eventIds = [];
+  const drawIds = [];
+  eventProfiles === null || eventProfiles === void 0 ? void 0 : eventProfiles.forEach(eventProfile => {
+    const event = tournamentRecord.events.find((event, index) => eventProfile.eventIndex !== undefined && index === eventProfile.eventIndex || eventProfile.eventName && event.eventName === eventProfile.eventName || eventProfile.eventId && event.eventId === eventProfile.eventId);
+
+    if (event !== null && event !== void 0 && event.gender) {
+      eventProfile.gender = event.gender;
+    }
+  });
+  const participantsCount = ((_tournamentRecord$par = tournamentRecord.participants) === null || _tournamentRecord$par === void 0 ? void 0 : _tournamentRecord$par.length) || undefined;
+  if (participantsCount && participantsProfile !== null && participantsProfile !== void 0 && participantsProfile.idPrefix) participantsProfile.idPrefix = `${participantsProfile.idPrefix}-${participantsCount}`;
+  const result = addTournamentParticipants({
+    startDate: tournamentRecord.startDate,
+    participantsProfile,
+    tournamentRecord,
+    eventProfiles,
+    drawProfiles,
+    uuids
+  });
+  if (!result.success) return result;
+
+  if (eventProfiles) {
+    var _tournamentRecord$eve;
+
+    let eventIndex = ((_tournamentRecord$eve = tournamentRecord.events) === null || _tournamentRecord$eve === void 0 ? void 0 : _tournamentRecord$eve.length) || 0;
+
+    for (const eventProfile of eventProfiles) {
+      let {
+        ratingsParameters
+      } = eventProfile;
+      const event = tournamentRecord.events.find((event, index) => eventProfile.eventIndex !== undefined && index === eventProfile.eventIndex || eventProfile.eventName && event.eventName === eventProfile.eventName || eventProfile.eventId && event.eventId === eventProfile.eventId);
+
+      if (!event) {
+        const {
+          error,
+          eventId,
+          drawIds: generatedDrawIds,
+          uniqueParticipantIds
+        } = generateEventWithFlights({
+          startDate: tournamentRecord.startDate,
+          allUniqueParticipantIds,
+          matchUpStatusProfile,
+          participantsProfile,
+          completeAllMatchUps,
+          autoEntryPositions,
+          randomWinningSide,
+          ratingsParameters,
+          tournamentRecord,
+          eventProfile,
+          eventIndex,
+          uuids
+        });
+        if (error) return {
+          error
+        };
+        if (generatedDrawIds) drawIds.push(...generatedDrawIds);
+        eventIds.push(eventId);
+        if (uniqueParticipantIds !== null && uniqueParticipantIds !== void 0 && uniqueParticipantIds.length) allUniqueParticipantIds.push(...uniqueParticipantIds);
+        eventIndex += 1;
+      } else {
+        const {
+          gender,
+          category,
+          eventType
+        } = event;
+        const {
+          drawProfiles
+        } = eventProfile;
+        const eventParticipantType = eventType === SINGLES ? INDIVIDUAL : eventType === DOUBLES ? PAIR : eventType;
+
+        if (drawProfiles) {
+          const {
+            stageParticipantsCount,
+            uniqueParticipantsCount,
+            uniqueParticipantStages
+          } = getStageParticipantsCount({
+            drawProfiles,
+            category,
+            gender
+          });
+          const {
+            uniqueDrawParticipants = [],
+            uniqueParticipantIds = []
+          } = uniqueParticipantStages ? generateEventParticipants({
+            event: {
+              eventType,
+              category,
+              gender
+            },
+            uniqueParticipantsCount,
+            participantsProfile,
+            ratingsParameters,
+            tournamentRecord,
+            eventProfile,
+            uuids
+          }) : {};
+          allUniqueParticipantIds.push(...uniqueParticipantIds);
+          const {
+            stageParticipants
+          } = getStageParticipants({
+            targetParticipants: tournamentRecord.participants || [],
+            allUniqueParticipantIds,
+            stageParticipantsCount,
+            eventParticipantType
+          });
+          let result = generateFlights({
+            uniqueDrawParticipants,
+            autoEntryPositions,
+            stageParticipants,
+            tournamentRecord,
+            drawProfiles,
+            category,
+            gender,
+            event
+          });
+          if (result.error) return result;
+          result = generateFlightDrawDefinitions({
+            matchUpStatusProfile,
+            completeAllMatchUps,
+            randomWinningSide,
+            tournamentRecord,
+            drawProfiles,
+            event
+          });
+          if (result.error) return result;
+          drawIds.push(...result.drawIds);
+        }
+      }
+    }
+  }
+
+  if (drawProfiles) {
+    let drawIndex = (tournamentRecord.events || []).map(event => {
+      var _event$drawDefinition;
+
+      return ((_event$drawDefinition = event.drawDefinitions) === null || _event$drawDefinition === void 0 ? void 0 : _event$drawDefinition.map(() => 1)) || [];
+    }).flat().reduce((a, b) => a + b, 0);
+
+    for (const drawProfile of drawProfiles) {
+      const {
+        drawId,
+        eventId,
+        event,
+        error,
+        uniqueParticipantIds
+      } = generateEventWithDraw({
+        startDate: tournamentRecord.startDate,
+        allUniqueParticipantIds,
+        matchUpStatusProfile,
+        participantsProfile,
+        completeAllMatchUps,
+        autoEntryPositions,
+        randomWinningSide,
+        ratingsParameters: ratingsParameters$1,
+        tournamentRecord,
+        drawProfile,
+        drawIndex,
+        goesTo,
+        uuids
+      });
+      if (error) return {
+        error
+      };
+      const result = addEvent({
+        tournamentRecord,
+        event
+      });
+      if (result.error) return result;
+      if (drawId) drawIds.push(drawId);
+      eventIds.push(eventId);
+      if (uniqueParticipantIds !== null && uniqueParticipantIds !== void 0 && uniqueParticipantIds.length) allUniqueParticipantIds.push(...uniqueParticipantIds);
+      drawIndex += 1;
+    }
+  }
+
+  const venueIds = venueProfiles !== null && venueProfiles !== void 0 && venueProfiles.length ? generateVenues({
+    tournamentRecord,
+    venueProfiles
+  }) : [];
+  let scheduledRounds;
+  let schedulerResult = {};
+
+  if (schedulingProfile) {
+    const result = generateScheduleTimes({
+      schedulingProfile,
+      tournamentRecord
+    });
+    if (result.error) return result;
+    scheduledRounds = result.scheduledRounds;
+
+    if (autoSchedule) {
+      const {
+        tournamentId
+      } = tournamentRecord;
+      const tournamentRecords = {
+        [tournamentId]: tournamentRecord
+      };
+      schedulerResult = scheduleProfileRounds({
+        tournamentRecords
+      });
+    }
+  }
+
+  return { ...SUCCESS,
+    drawIds,
+    eventIds,
+    venueIds,
+    scheduledRounds,
+    schedulerResult
+  };
+}
+
+const amendsGovernor = {
+  anonymizeTournamentRecord,
+  modifyTournamentRecord
+};
+
+function generateSchedulingProfile({
+  schedulingProfile,
+  tournamentRecord
+}) {
+  if (typeof schedulingProfile !== 'object') return {
+    error: INVALID_VALUES
+  };
+  const containedStructures = getContainedStructures({
+    tournamentRecord
+  }).containedStructures;
+  const {
+    matchUps
+  } = allTournamentMatchUps({
+    tournamentRecord
+  });
+  const {
+    tournamentId
+  } = tournamentRecord;
+  const scheduledRounds = [];
+
+  for (const dateProfile of schedulingProfile) {
+    const {
+      scheduleDate,
+      venues = []
+    } = dateProfile;
+
+    for (const venue of venues) {
+      const {
+        rounds,
+        venueId
+      } = venue;
+
+      for (const round of rounds) {
+        const {
+          drawId,
+          winnerFinishingPositionRange,
+          roundSegment
+        } = round;
+        const targetMatchUps = matchUps.filter(matchUp => {
+          var _matchUp$finishingPos;
+
+          const targetRange = (winnerFinishingPositionRange === null || winnerFinishingPositionRange === void 0 ? void 0 : winnerFinishingPositionRange.indexOf('-')) > 0 && winnerFinishingPositionRange.split('-').map(x => +x);
+          const range = (_matchUp$finishingPos = matchUp.finishingPositionRange) === null || _matchUp$finishingPos === void 0 ? void 0 : _matchUp$finishingPos.winner;
+          const target = matchUp.drawId === drawId && (!round.roundNumber || matchUp.roundNumber === round.roundNumber) && (!range || !targetRange || intersection(range, targetRange).length === 2);
+          return target;
+        });
+        const targetMatchUp = targetMatchUps[0];
+
+        if (targetMatchUp) {
+          const {
+            eventId,
+            roundNumber,
+            drawName,
+            structureName,
+            roundName
+          } = targetMatchUp;
+          let structureId = targetMatchUp.structureId;
+
+          if (roundNumber && !winnerFinishingPositionRange) {
+            structureId = Object.keys(containedStructures).find(containingStructureId => containedStructures[containingStructureId].includes(structureId));
+          }
+
+          const roundToSchedule = {
+            tournamentId,
+            eventId,
+            drawId,
+            structureId,
+            roundNumber,
+            roundSegment
+          };
+          let result = addSchedulingProfileRound({
+            tournamentRecords: {
+              [tournamentId]: tournamentRecord
+            },
+            scheduleDate,
+            venueId,
+            round: roundToSchedule
+          });
+          if (result.error) return result;
+          scheduledRounds.push({
+            drawName,
+            structureName,
+            roundName,
+            ...roundToSchedule
+          });
+        }
+      }
+    }
+  }
+
+  return {
+    scheduledRounds
+  };
+}
+
 /**
  *
  * Generate a complete tournamentRecord from the following attributes
@@ -51748,6 +51858,8 @@ function generateTournamentRecord({
         allUniqueParticipantIds = [];
 
   if (drawProfiles) {
+    let drawIndex = 0;
+
     for (const drawProfile of drawProfiles) {
       const {
         drawId,
@@ -51766,6 +51878,7 @@ function generateTournamentRecord({
         tournamentRecord,
         drawProfile,
         startDate,
+        drawIndex,
         goesTo,
         uuids
       });
@@ -51780,10 +51893,13 @@ function generateTournamentRecord({
       if (drawId) drawIds.push(drawId);
       eventIds.push(eventId);
       if (uniqueParticipantIds !== null && uniqueParticipantIds !== void 0 && uniqueParticipantIds.length) allUniqueParticipantIds.push(...uniqueParticipantIds);
+      drawIndex += 1;
     }
   }
 
   if (eventProfiles) {
+    let eventIndex = 0;
+
     for (const eventProfile of eventProfiles) {
       const {
         error,
@@ -51800,6 +51916,7 @@ function generateTournamentRecord({
         ratingsParameters: ratingsParameters$1,
         tournamentRecord,
         eventProfile,
+        eventIndex,
         startDate,
         uuids
       });
@@ -51809,6 +51926,7 @@ function generateTournamentRecord({
       if (generatedDrawIds) drawIds.push(...generatedDrawIds);
       eventIds.push(eventId);
       if (uniqueParticipantIds !== null && uniqueParticipantIds !== void 0 && uniqueParticipantIds.length) allUniqueParticipantIds.push(...uniqueParticipantIds);
+      eventIndex += 1;
     }
   }
 
@@ -52064,4 +52182,5 @@ exports.tournamentEngine = tournamentEngine;
 exports.tournamentEngineAsync = tournamentEngineAsync;
 exports.utilities = utilities;
 exports.venueConstants = venueConstants;
+exports.version = factoryVersion;
 //# sourceMappingURL=tods-competition-factory.development.cjs.js.map