tods-competition-factory 1.8.12 → 1.8.14

package/dist/index.mjs

@@ -87,6 +87,10 @@ function tiebreakFormat(tieobject) {
   return void 0;
 }
 
+function numericSort(a, b) {
+  return a - b;
+}
+
 function ensureInt(val) {
   if (typeof val === "number")
     return parseInt(val.toString());
@@ -98,6 +102,13 @@ function isPowerOf2(n) {
     return false;
   return n && (n & n - 1) === 0;
 }
+function median(arr) {
+  if (!arr.length)
+    return void 0;
+  const s = [...arr].sort(numericSort);
+  const mid = Math.floor(s.length / 2);
+  return s.length % 2 ? s[mid] : (s[mid - 1] + s[mid]) / 2;
+}
 function deriveExponent(n) {
   if (!isPowerOf2(n))
     return false;
@@ -2063,10 +2074,6 @@ function generateTimeCode(index = 0) {
   return uidate.getTime().toString(36).slice(-6).toUpperCase();
 }
 
-function numericSort(a, b) {
-  return a - b;
-}
-
 function JSON2CSV(arrayOfJSON, config) {
   if (config && typeof config !== "object")
     return INVALID_VALUES;
@@ -2375,7 +2382,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.8.12";
+  return "1.8.14";
 }
 
 function getObjectTieFormat(obj) {
@@ -5023,36 +5030,6 @@ function getFlightProfile({ event, eventId }) {
   return { flightProfile };
 }
 
-function getEvent({ tournamentRecord, drawDefinition, event, context }) {
-  if (!tournamentRecord)
-    return { error: MISSING_TOURNAMENT_RECORD };
-  if (!event)
-    return { error: MISSING_EVENT };
-  const eventCopy = makeDeepCopy(event);
-  if (context)
-    Object.assign(eventCopy, context);
-  const drawDefinitionCopy = drawDefinition && eventCopy.drawDefinitions?.find(
-    ({ drawId }) => drawDefinition.drawId === drawId
-  );
-  return definedAttributes({
-    event: eventCopy,
-    drawDefinition: drawDefinitionCopy
-  });
-}
-function getEvents({ tournamentRecord, context, inContext }) {
-  if (!tournamentRecord)
-    return { error: MISSING_TOURNAMENT_RECORD };
-  const { tournamentId } = tournamentRecord;
-  const eventCopies = (tournamentRecord.events || []).map((event) => {
-    const eventCopy = makeDeepCopy(event);
-    if (context)
-      Object.assign(eventCopy, context);
-    if (inContext)
-      Object.assign(eventCopy, { tournamentId });
-    return eventCopy;
-  });
-  return { events: eventCopies };
-}
 function findEvent({
   tournamentRecord,
   eventId,
@@ -5111,26 +5088,6 @@ function findEvent({
     })
   };
 }
-function getDrawDefinition$2({ tournamentRecord, drawId }) {
-  if (!tournamentRecord)
-    return { error: MISSING_TOURNAMENT_RECORD };
-  if (!drawId) {
-    return { error: MISSING_DRAW_ID };
-  }
-  const target = (tournamentRecord.events || []).reduce((target2, event) => {
-    const candidate = (event.drawDefinitions || []).reduce(
-      (drawDefinition, candidate2) => {
-        return candidate2.drawId === drawId ? candidate2 : drawDefinition;
-      },
-      void 0
-    );
-    return candidate && candidate.drawId === drawId ? { event, drawDefinition: candidate } : target2;
-  }, void 0);
-  return target ? { ...target, SUCCESS } : decorateResult({
-    result: { error: DRAW_DEFINITION_NOT_FOUND },
-    stack: "getDrawDefinition"
-  });
-}
 
 function addExtension$1(params) {
   if (typeof params !== "object")
@@ -16664,7 +16621,7 @@ function getMatchUpDependencies(params) {
   const allTournamentRecords = Object.values(tournamentRecords);
   const allLinks = allTournamentRecords.reduce(
     (allLinks2, tournamentRecord2) => {
-      return allLinks2.concat(tournamentRecord2.events || []).map(
+      return allLinks2.concat(tournamentRecord2.events ?? []).map(
         (event) => (event.drawDefinitions || []).map(
           (drawDefinition2) => drawDefinition2.links || []
         )
@@ -16696,7 +16653,7 @@ function getMatchUpDependencies(params) {
     for (const sourceStructureId of sourceStructureIds) {
       positionDependencies[sourceStructureId] = [];
     }
-    for (const matchUp of matchUps || []) {
+    for (const matchUp of matchUps ?? []) {
       const sourceStructureId = matchUp.containerStructureId || matchUp.structureId;
       if (sourceStructureIds.includes(sourceStructureId)) {
         positionDependencies[sourceStructureId].push(matchUp.matchUpId);
@@ -17287,6 +17244,26 @@ function removeExtraneousAttributes(matchUps, matchUpFormatMap = {}) {
   }
 }
 
+function getAssignedParticipantIds({
+  drawDefinition,
+  stages
+}) {
+  if (!drawDefinition)
+    return { error: MISSING_DRAW_DEFINITION };
+  const stageStructures = (drawDefinition?.structures || []).filter(
+    (structure) => !stages?.length || structure.stage && stages.includes(structure.stage)
+  );
+  const assignedParticipantIds = unique(
+    stageStructures.map((structure) => {
+      const { positionAssignments } = getPositionAssignments$1({
+        structure
+      });
+      return positionAssignments ? positionAssignments.map(extractAttributes("participantId")) : [];
+    }).flat().filter(Boolean)
+  );
+  return { ...SUCCESS, assignedParticipantIds };
+}
+
 function participantScaleItem({
   requireTimeStamp,
   scaleAttributes,
@@ -20471,6 +20448,77 @@ function addMatchUpResumeTime$2({
   }
 }
 
+function getEventIdsAndDrawIds({
+  tournamentRecords
+}) {
+  if (!tournamentRecords)
+    return { error: MISSING_TOURNAMENT_RECORDS };
+  const tournamentIds = Object.keys(tournamentRecords);
+  return tournamentIds.reduce(
+    (aggregator, tournamentId) => {
+      aggregator.tournamentIdMap[tournamentId] = [];
+      const tournamentRecord = tournamentRecords[tournamentId];
+      const events = tournamentRecord.events || [];
+      const eventIds = events.map(({ eventId }) => eventId);
+      const drawIds = events.map(
+        (event) => (event.drawDefinitions || []).map(({ drawId }) => drawId)
+      ).flat();
+      aggregator.tournamentIdMap[tournamentId].push(...eventIds, ...drawIds);
+      aggregator.eventIds.push(...eventIds);
+      aggregator.drawIds.push(...drawIds);
+      return aggregator;
+    },
+    { eventIds: [], drawIds: [], tournamentIdMap: {} }
+  );
+}
+
+function findTournamentId({
+  tournamentRecords,
+  eventId,
+  drawId
+}) {
+  const { tournamentIdMap } = getEventIdsAndDrawIds({ tournamentRecords });
+  const tournamentIds = tournamentIdMap ? Object.keys(tournamentIdMap) : [];
+  return tournamentIds.find(
+    (tournamentId) => eventId && tournamentIdMap?.[tournamentId].includes(eventId) || drawId && tournamentIdMap?.[tournamentId].includes(drawId)
+  );
+}
+
+function getDrawDefinition$1({
+  tournamentRecords,
+  tournamentRecord,
+  tournamentId,
+  drawId
+}) {
+  if (!tournamentRecord && !tournamentRecords)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  if (!drawId)
+    return { error: MISSING_DRAW_ID };
+  if (!tournamentRecord && tournamentRecords) {
+    if (typeof tournamentId !== "string") {
+      tournamentId = findTournamentId({ tournamentRecords, drawId });
+      if (!tournamentId)
+        return { error: MISSING_TOURNAMENT_ID };
+    }
+    tournamentRecord = tournamentRecords[tournamentId];
+    if (!tournamentRecord)
+      return { error: MISSING_TOURNAMENT_RECORD };
+  }
+  const result = tournamentRecord && findEvent({ tournamentRecord, drawId });
+  if (!result?.drawDefinition) {
+    return decorateResult({
+      result: { error: DRAW_DEFINITION_NOT_FOUND },
+      stack: "getDrawDefinition"
+    });
+  }
+  return {
+    drawDefinition: result.drawDefinition,
+    event: result.event,
+    tournamentRecord,
+    ...SUCCESS
+  };
+}
+
 function bulkScheduleMatchUps$1({
   errorOnAnachronism = false,
   checkChronology = true,
@@ -20498,7 +20546,7 @@ function bulkScheduleMatchUps$1({
   if (!inContextMatchUps) {
     inContextMatchUps = allTournamentMatchUps({
       tournamentRecord
-    })?.matchUps || [];
+    })?.matchUps ?? [];
   }
   const drawIdMap = inContextMatchUps.reduce((drawIdMap2, matchUp) => {
     const { matchUpId, drawId } = matchUp;
@@ -20511,12 +20559,14 @@ function bulkScheduleMatchUps$1({
   }, {});
   const detailMatchUpIds = matchUpDetails?.map((detail) => detail.matchUpId);
   for (const drawId of Object.keys(drawIdMap)) {
-    const { drawDefinition } = getDrawDefinition$2({
+    const { drawDefinition } = getDrawDefinition$1({
       tournamentRecord,
       drawId
     });
+    if (!drawDefinition)
+      continue;
     const drawMatchUpIds = drawIdMap[drawId].filter(
-      (matchUpId) => matchUpIds?.includes(matchUpId) || detailMatchUpIds?.includes(matchUpId)
+      (matchUpId) => matchUpIds?.includes(matchUpId) ?? detailMatchUpIds?.includes(matchUpId)
     );
     const drawMatchUps = allDrawMatchUps$1({
       inContext: false,
@@ -20594,42 +20644,6 @@ function bulkScheduleMatchUps({
   return warnings.length ? { ...SUCCESS, scheduled, warnings } : { ...SUCCESS, scheduled };
 }
 
-function getEventIdsAndDrawIds({
-  tournamentRecords
-}) {
-  if (!tournamentRecords)
-    return { error: MISSING_TOURNAMENT_RECORDS };
-  const tournamentIds = Object.keys(tournamentRecords);
-  return tournamentIds.reduce(
-    (aggregator, tournamentId) => {
-      aggregator.tournamentIdMap[tournamentId] = [];
-      const tournamentRecord = tournamentRecords[tournamentId];
-      const events = tournamentRecord.events || [];
-      const eventIds = events.map(({ eventId }) => eventId);
-      const drawIds = events.map(
-        (event) => (event.drawDefinitions || []).map(({ drawId }) => drawId)
-      ).flat();
-      aggregator.tournamentIdMap[tournamentId].push(...eventIds, ...drawIds);
-      aggregator.eventIds.push(...eventIds);
-      aggregator.drawIds.push(...drawIds);
-      return aggregator;
-    },
-    { eventIds: [], drawIds: [], tournamentIdMap: {} }
-  );
-}
-
-function findTournamentId({
-  tournamentRecords,
-  eventId,
-  drawId
-}) {
-  const { tournamentIdMap } = getEventIdsAndDrawIds({ tournamentRecords });
-  const tournamentIds = tournamentIdMap ? Object.keys(tournamentIdMap) : [];
-  return tournamentIds.find(
-    (tournamentId) => eventId && tournamentIdMap?.[tournamentId].includes(eventId) || drawId && tournamentIdMap?.[tournamentId].includes(drawId)
-  );
-}
-
 function getProjectedDualWinningSide({
   drawDefinition,
   matchUpStatus,
@@ -32897,7 +32911,7 @@ function jinnScheduler({
         const tournamentRecord = tournamentRecords[tournamentId];
         if (tournamentRecord) {
           Object.keys(matchUpMap[tournamentId]).forEach((drawId) => {
-            const { drawDefinition } = getDrawDefinition$2({
+            const { drawDefinition } = getDrawDefinition$1({
               tournamentRecord,
               drawId
             });
@@ -33341,7 +33355,7 @@ function proScheduler({
         const tournamentRecord = tournamentRecords[tournamentId];
         if (tournamentRecord) {
           Object.keys(matchUpMap[tournamentId]).forEach((drawId) => {
-            const { drawDefinition } = getDrawDefinition$2({
+            const { drawDefinition } = getDrawDefinition$1({
               tournamentRecord,
               drawId
             });
@@ -33988,7 +34002,7 @@ function toggleParticipantCheckInState(params) {
   if (!tournamentRecords || !tournamentId || !participantId || !matchUpId)
     return { error: MISSING_VALUE, stack: "toggleParticipantCheckInState" };
   const tournamentRecord = tournamentRecords[tournamentId];
-  const { drawDefinition, event } = getDrawDefinition$2({
+  const { drawDefinition, event } = getDrawDefinition$1({
     tournamentRecord,
     drawId
   });
@@ -34011,16 +34025,18 @@ function removeMatchUpCourtAssignment$1(params) {
   const tournamentRecord = tournamentRecords[tournamentId];
   if (!tournamentRecord)
     return { error: MISSING_TOURNAMENT_RECORD };
-  const { drawDefinition, event } = getDrawDefinition$2({
+  const { drawDefinition, event } = getDrawDefinition$1({
     tournamentRecord,
     drawId
   });
+  if (!drawDefinition)
+    return { error: MISSING_DRAW_DEFINITION };
   const result = findMatchUp$1({ drawDefinition, event, matchUpId });
   if (result.error)
     return result;
   if (result?.matchUp?.matchUpType === TEAM_MATCHUP) {
     const { itemValue: allocatedCourts } = latestVisibleTimeItemValue({
-      timeItems: result.matchUp.timeItems || [],
+      timeItems: result.matchUp.timeItems ?? [],
       itemType: ALLOCATE_COURTS
     });
     const itemValue = courtId && allocatedCourts.filter((court) => court.courtId !== courtId);
@@ -34282,7 +34298,7 @@ function scheduleMatchUps({
     ({ matchUpId }) => !overLimitMatchUpIds.includes(matchUpId)
   );
   let iterations = 0;
-  const failSafe = scheduleTimes?.length || 0;
+  const failSafe = scheduleTimes?.length ?? 0;
   const { personRequests } = getPersonRequests({
     tournamentRecords,
     requestType: DO_NOT_SCHEDULE
@@ -34367,7 +34383,7 @@ function scheduleMatchUps({
     const tournamentRecord = tournamentRecords[tournamentId];
     if (tournamentRecord) {
       Object.keys(matchUpMap[tournamentId]).forEach((drawId) => {
-        const { drawDefinition } = getDrawDefinition$2({
+        const { drawDefinition } = getDrawDefinition$1({
           tournamentRecord,
           drawId
         });
@@ -34404,9 +34420,6 @@ function scheduleMatchUps({
           });
         }
       });
-    } else {
-      if (getDevContext())
-        console.log(MISSING_TOURNAMENT_ID);
     }
   });
   const noTimeMatchUpIds = getMatchUpIds(matchUpsToSchedule);
@@ -34472,10 +34485,12 @@ function reorderUpcomingMatchUps(params) {
     drawId
   }) {
     const tournamentRecord = tournamentRecords[tournamentId];
-    const { drawDefinition } = getDrawDefinition$2({
+    const { drawDefinition } = getDrawDefinition$1({
       tournamentRecord,
       drawId
     });
+    if (!drawDefinition)
+      return { error: DRAW_DEFINITION_NOT_FOUND };
     return addMatchUpScheduledTime$2({
       drawDefinition,
       scheduledTime,
@@ -34826,7 +34841,7 @@ function bulkRescheduleMatchUps$1({
   );
   const dayTotalMinutes = 1440;
   for (const drawId of Object.keys(drawIdMap)) {
-    const result = getDrawDefinition$2({
+    const result = getDrawDefinition$1({
       tournamentRecord,
       drawId
     });
@@ -34898,7 +34913,7 @@ function bulkRescheduleMatchUps$1({
   const updatedInContext = allTournamentMatchUps({
     matchUpFilters: { matchUpIds },
     tournamentRecord
-  }).matchUps || [];
+  }).matchUps ?? [];
   const rescheduled = updatedInContext.filter(
     ({ matchUpId }) => rescheduledMatchUpIds.includes(matchUpId)
   );
@@ -35193,7 +35208,7 @@ function matchUpScheduleChange(params) {
   function assignMatchUp(params2) {
     const { tournamentRecords: tournamentRecords2, tournamentId, matchUp, drawId } = params2;
     const tournamentRecord = tournamentRecords2[tournamentId];
-    const { drawDefinition } = getDrawDefinition$2({
+    const { drawDefinition } = getDrawDefinition$1({
       tournamentRecord,
       drawId
     });
@@ -35647,31 +35662,6 @@ function addMatchUpCourtOrder(params) {
     matchUpId
   });
 }
-function getDrawDefinition$1({
-  tournamentRecords,
-  tournamentId,
-  drawId
-}) {
-  if (!tournamentRecords)
-    return { error: MISSING_TOURNAMENT_RECORDS };
-  if (!drawId)
-    return { error: MISSING_DRAW_ID };
-  if (typeof tournamentId !== "string") {
-    tournamentId = findTournamentId({ tournamentRecords, drawId });
-    if (!tournamentId)
-      return { error: MISSING_TOURNAMENT_ID };
-  }
-  const tournamentRecord = tournamentRecords[tournamentId];
-  if (!tournamentRecord)
-    return { error: MISSING_TOURNAMENT_RECORD };
-  const result = findEvent({ tournamentRecord, drawId });
-  if (result.error)
-    return decorateResult({
-      stack: "addScheduleItems.getDrawDefinition",
-      result
-    });
-  return { drawDefinition: result.drawDefinition, tournamentRecord };
-}
 
 const scheduleGovernor$1 = {
   scheduleMatchUps,
@@ -36952,7 +36942,7 @@ function removeCourtAssignment({
   } else {
     if (!tournamentRecord)
       return { error: MISSING_TOURNAMENT_RECORD };
-    const matchUps = allTournamentMatchUps({ tournamentRecord, inContext: false }).matchUps || [];
+    const matchUps = allTournamentMatchUps({ tournamentRecord, inContext: false }).matchUps ?? [];
     ({ matchUp } = getMatchUp$1({ matchUps, matchUpId }));
   }
   if (!matchUp)
@@ -41088,8 +41078,8 @@ function organizeDrawPositionOptions({
 }
 
 function getUnplacedParticipantIds({
-  participantIds,
-  positionAssignments
+  positionAssignments,
+  participantIds
 }) {
   const assignedParticipantIds = positionAssignments.map(
     (assignment) => assignment.participantId
@@ -44728,21 +44718,6 @@ function setPositionAssignments$1({
   return { ...SUCCESS };
 }
 
-function getAssignedParticipantIds({
-  drawDefinition,
-  stages
-}) {
-  const stageStructures = (drawDefinition?.structures || []).filter(
-    (structure) => !stages?.length || structure.stage && stages.includes(structure.stage)
-  );
-  return stageStructures.map((structure) => {
-    const { positionAssignments } = getPositionAssignments$1({
-      structure
-    });
-    return positionAssignments ? positionAssignments.map(extractAttributes("participantId")) : [];
-  }).flat();
-}
-
 function refreshEntryPositions(params) {
   const stagedEntries = (params?.entries ?? []).filter(Boolean).reduce((stages, entry) => {
     const { entryStage, entryStatus } = entry;
@@ -44815,7 +44790,7 @@ function modifyEntriesStatus({
     const participantIds2 = getAssignedParticipantIds({
       stages: stage && [stage],
       drawDefinition: drawDefinition2
-    });
+    }).assignedParticipantIds ?? [];
     assignedParticipantIds.push(...participantIds2);
   });
   const tournamentParticipants = tournamentRecord?.participants || [];
@@ -45288,7 +45263,7 @@ function removeEventEntries({
     return decorateResult({ result: { error: INVALID_PARTICIPANT_ID }, stack });
   }
   const assignedParticipantIds = (event.drawDefinitions ?? []).flatMap(
-    (drawDefinition) => getAssignedParticipantIds({ drawDefinition })
+    (drawDefinition) => getAssignedParticipantIds({ drawDefinition }).assignedParticipantIds ?? []
   );
   const statusParticipantIds = (entryStatuses?.length && event.entries?.filter(
     (entry) => entry.entryStatus && entryStatuses.includes(entry.entryStatus)
@@ -48108,7 +48083,7 @@ function positionActions$1(params) {
   const stageAssignedParticipantIds = getAssignedParticipantIds({
     drawDefinition,
     stages
-  });
+  }).assignedParticipantIds ?? [];
   const unassignedParticipantIds = stageEntries.filter(
     (entry) => !stageAssignedParticipantIds.includes(entry.participantId)
   ).map((entry) => entry.participantId);
@@ -48448,7 +48423,7 @@ function removeEntry({
   const assignedParticipantIds = getAssignedParticipantIds({
     drawDefinition,
     stages
-  });
+  }).assignedParticipantIds ?? [];
   const isAssignedParticipant = assignedParticipantIds.includes(participantId);
   if (isAssignedParticipant)
     return { error: EXISTING_PARTICIPANT_DRAW_POSITION_ASSIGNMENT };
@@ -48467,6 +48442,7 @@ function removeEntry({
 }
 
 const entryGovernor = {
+  getAssignedParticipantIds,
   setStageAlternatesCount,
   setStageWildcardsCount,
   setStageQualifiersCount,
@@ -51831,8 +51807,8 @@ function setParticipantScaleItem(params) {
   return equivalentValue && {
     ...SUCCESS,
     info: VALUE_UNCHANGED,
-    existingValue: scaleItem.scaleValue
-  } || participant && { ...SUCCESS, newValue: scaleItem.scaleValue } || {
+    existingValue: scaleItem?.scaleValue
+  } || participant && { ...SUCCESS, newValue: scaleItem?.scaleValue } || {
     error: PARTICIPANT_NOT_FOUND
   };
 }
@@ -55587,7 +55563,7 @@ function deleteDrawDefinitions({
           action: DELETE_DRAW_DEFINITIONS,
           payload: {
             drawDefinitions: [drawDefinition],
-            eventId: eventId || event?.eventId,
+            eventId: eventId ?? event?.eventId,
             auditData
           }
         };
@@ -55595,7 +55571,7 @@ function deleteDrawDefinitions({
         deletedDrawsDetail.push(
           definedAttributes({
             tournamentId: tournamentRecord.tournamentId,
-            eventId: eventId || event?.eventId,
+            eventId: eventId ?? event?.eventId,
             qualifyingPositionAssignments,
             positionAssignments,
             auditData,
@@ -56708,7 +56684,7 @@ function removeDrawEntries({
   const assignedParticipantIds = getAssignedParticipantIds({
     drawDefinition,
     stages
-  });
+  }).assignedParticipantIds ?? [];
   const someAssignedParticipantIds = overlap(
     assignedParticipantIds,
     participantIds
@@ -59290,6 +59266,7 @@ const eventGovernor = {
   getAvailablePlayoffRounds: getAvailablePlayoffProfiles,
   // to be deprecated
   getAvailablePlayoffProfiles,
+  getAssignedParticipantIds,
   deleteDrawDefinitions,
   addPlayoffStructures,
   modifyDrawDefinition,
@@ -59763,6 +59740,182 @@ function getMatchUpsStats({ profileBands, tournamentRecord, matchUps }) {
   };
 }
 
+function getEvent({
+  tournamentRecord,
+  drawDefinition,
+  context,
+  event
+}) {
+  if (!tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  if (!event)
+    return { error: MISSING_EVENT };
+  const eventCopy = makeDeepCopy(event);
+  if (context)
+    Object.assign(eventCopy, context);
+  const drawDefinitionCopy = drawDefinition && eventCopy.drawDefinitions?.find(
+    ({ drawId }) => drawDefinition.drawId === drawId
+  );
+  return definedAttributes({
+    drawDefinition: drawDefinitionCopy,
+    event: eventCopy
+  });
+}
+function getEvents({
+  tournamentRecord,
+  withScaleValues,
+  scaleEventType,
+  inContext,
+  eventIds,
+  drawIds,
+  context
+}) {
+  if (!tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  const { tournamentId } = tournamentRecord;
+  const eventCopies = (tournamentRecord.events ?? []).filter(
+    ({ eventId }) => !eventIds || Array.isArray(eventIds) && eventIds.includes(eventId)
+  ).map((event) => {
+    const eventCopy = makeDeepCopy(event);
+    if (inContext)
+      Object.assign(eventCopy, { tournamentId });
+    if (context)
+      Object.assign(eventCopy, context);
+    return eventCopy;
+  });
+  const eventsMap = {};
+  if (withScaleValues) {
+    const participantMap = getParticipants$1({
+      withScaleValues: true,
+      tournamentRecord
+    }).participantMap;
+    const sum = (values) => values.reduce((total, value) => total + parseFloat(value), 0);
+    for (const event of eventCopies) {
+      const eventType = scaleEventType ?? event.eventType;
+      const eventId = event.eventId;
+      if (!eventsMap[eventId])
+        eventsMap[eventId] = {
+          ratingsStats: {},
+          ratings: {},
+          ranking: {},
+          draws: {}
+        };
+      const selectedEntries = (event.entries ?? []).filter(
+        ({ entryStatus }) => STRUCTURE_SELECTED_STATUSES.includes(entryStatus)
+      );
+      const participantIds = selectedEntries.map(extractAttributes("participantId"));
+      const processParticipant = (participant) => {
+        if (participant?.ratings?.[eventType]) {
+          for (const rating of participant?.ratings?.[eventType] ?? []) {
+            const scaleName = rating.scaleName;
+            if (!eventsMap[eventId].ratings[scaleName])
+              eventsMap[eventId].ratings[scaleName] = [];
+            const accessor = ratingsParameters[scaleName]?.accessor;
+            if (accessor) {
+              const value = parseFloat(rating.scaleValue?.[accessor]);
+              if (value)
+                eventsMap[eventId].ratings[scaleName].push(value);
+            }
+          }
+        }
+      };
+      for (const participantId of participantIds) {
+        const participant = participantMap?.[participantId]?.participant;
+        if (participant?.participantType !== INDIVIDUAL) {
+          for (const individualParticipantId of participant?.individualParticipantIds ?? []) {
+            const individualParticipant = participantMap?.[individualParticipantId]?.participant;
+            processParticipant(individualParticipant);
+          }
+        } else {
+          processParticipant(participant);
+        }
+      }
+      const ratings = eventsMap[eventId].ratings;
+      for (const scaleName of Object.keys(ratings)) {
+        eventsMap[eventId].ratingsStats[scaleName] = {
+          avg: sum(ratings[scaleName]) / ratings[scaleName].length,
+          median: median(ratings[scaleName]),
+          max: Math.max(...ratings[scaleName]),
+          min: Math.min(...ratings[scaleName])
+        };
+      }
+      const processFlight = (drawId, participantIds2) => {
+        const processParticipant2 = (participant) => {
+          if (participant?.ratings?.[eventType]) {
+            for (const rating of participant?.ratings?.[eventType] ?? []) {
+              const scaleName = rating.scaleName;
+              if (!eventsMap[eventId].draws[drawId].ratings[scaleName])
+                eventsMap[eventId].draws[drawId].ratings[scaleName] = [];
+              const accessor = ratingsParameters[scaleName]?.accessor;
+              if (accessor) {
+                const value = parseFloat(rating.scaleValue?.[accessor]);
+                if (value) {
+                  eventsMap[eventId].draws[drawId].ratings[scaleName].push(
+                    value
+                  );
+                }
+              }
+            }
+          }
+        };
+        for (const participantId of participantIds2.filter(Boolean)) {
+          const participant = participantMap?.[participantId]?.participant;
+          if (participant?.participantType !== INDIVIDUAL) {
+            for (const individualParticipantId of participant?.individualParticipantIds ?? []) {
+              const individualParticipant = participantMap?.[individualParticipantId]?.participant;
+              processParticipant2(individualParticipant);
+            }
+          } else {
+            processParticipant2(participant);
+          }
+        }
+      };
+      const processedDrawIds = [];
+      const ignoreDrawId = (drawId) => drawIds?.length && drawIds.includes(drawId) || processedDrawIds.includes(drawId);
+      for (const drawDefinition of event.drawDefinitions ?? []) {
+        const drawId = drawDefinition.drawId;
+        if (ignoreDrawId(drawId))
+          continue;
+        const participantIds2 = getAssignedParticipantIds({
+          drawDefinition
+        }).assignedParticipantIds ?? [];
+        if (!eventsMap[eventId].draws[drawId])
+          eventsMap[eventId].draws[drawId] = {
+            ratingsStats: {},
+            ratings: {},
+            ranking: {}
+          };
+        processedDrawIds.push(drawId);
+        processFlight(drawId, participantIds2);
+      }
+      const flightProfile = getFlightProfile({ event }).flightProfile;
+      for (const flight of flightProfile?.flights ?? []) {
+        const drawId = flight.drawId;
+        if (ignoreDrawId(drawId))
+          continue;
+        const participantIds2 = flight.drawEntries.map(extractAttributes("participantId"));
+        processFlight(drawId, participantIds2);
+      }
+      for (const drawId of processedDrawIds) {
+        const ratings2 = eventsMap[eventId].draws[drawId].ratings;
+        for (const scaleName of Object.keys(ratings2)) {
+          eventsMap[eventId].draws[drawId].ratingsStats[scaleName] = {
+            avg: sum(ratings2[scaleName]) / ratings2[scaleName].length,
+            max: Math.max(...ratings2[scaleName]),
+            min: Math.min(...ratings2[scaleName]),
+            median: median(ratings2[scaleName])
+          };
+        }
+      }
+    }
+  }
+  return definedAttributes({
+    eventScaleValues: eventsMap,
+    events: eventCopies,
+    ...SUCCESS
+  });
+}
+
 function bulkUpdatePublishedEventIds({ tournamentRecord, outcomes }) {
   if (!tournamentRecord)
     return { error: MISSING_TOURNAMENT_RECORD };
@@ -59958,6 +60111,8 @@ function positionActions(params) {
 function getDrawDefinition({ tournamentRecord, drawDefinition }) {
   if (!tournamentRecord)
     return { error: MISSING_TOURNAMENT_RECORD };
+  if (!drawDefinition)
+    return { error: MISSING_DRAW_ID };
   return { drawDefinition: makeDeepCopy(drawDefinition) };
 }
 const queryGovernor = {
@@ -64374,6 +64529,7 @@ const utilities = {
   generateRange,
   generateScoreString,
   generateTimeCode,
+  getAssignedParticipantIds,
   getCategoryAgeDetails,
   getScaleValues,
   getTimeItem,