tods-competition-factory 1.8.9 → 1.8.11

package/dist/forge/query.mjs

@@ -209,10 +209,6 @@ const POLICY_NOT_FOUND = {
   message: "Policy not found",
   code: "ERR_NOT_FOUND_POLICY"
 };
-const MISSING_SCORING_POLICY = {
-  message: "Missing scoring policy / matchUpFormats",
-  code: "ERR_MISSING_POLICY_SCORING_MATCHUP_FORMATS"
-};
 const MISSING_COURT_ID = {
   message: "Missing courtId",
   code: "ERR_MISSING_COURT_ID"
@@ -237,10 +233,6 @@ const MISSING_PARTICIPANT = {
   message: "Missing participant",
   code: "ERR_MISSING_PARTICIPANT"
 };
-const MISSING_PARTICIPANTS = {
-  message: "Missing participants",
-  code: "ERR_MISSING_PARTICIPANTS"
-};
 const MISSING_PARTICIPANT_ID = {
   message: "Missing participantId",
   code: "ERR_MISSING_PARTICIPANT_ID"
@@ -289,14 +281,6 @@ const INVALID_SCALE_ITEM = {
   message: "Invalid scaleItem",
   code: "ERR_INVALID_SCALE_ITEM"
 };
-const SCALE_ITEM_NOT_FOUND = {
-  message: "No scaleItem found",
-  code: "ERR_NOT_FOUND_SCALE_ITEM"
-};
-const INVALID_OBJECT = {
-  message: "Invalid object",
-  code: "ERR_INVALID_OBJECT"
-};
 const INVALID_VALUES = {
   message: "Invalid values",
   code: "ERR_INVALID_VALUES"
@@ -853,70 +837,17 @@ function UUID() {
 }
 
 const APPLIED_POLICIES = "appliedPolicies";
-const AUDIT_POSITION_ACTIONS = "positionActions";
 const CONTEXT = "context";
-const DELEGATED_OUTCOME = "delegatedOutcome";
 const DISABLED = "disabled";
 const DISABLE_LINKS = "disableLinks";
-const DISABLE_AUTO_CALC = "disableAutoCalc";
-const DRAW_DELETIONS = "drawDeletions";
-const DRAW_PROFILE = "drawProfile";
-const ENTRY_PROFILE = "entryProfile";
-const EVENT_PROFILE = "eventProfile";
-const FACTORY = "factory";
 const FLIGHT_PROFILE = "flightProfile";
-const GROUPING_ATTRIBUTE = "groupingAttribute";
 const LINEUPS = "lineUps";
 const LINKED_TOURNAMENTS = "linkedTournamentsIds";
-const MATCHUP_HISTORY = "matchUpHistory";
-const PARTICIPANT_REPRESENTATIVES = "participantRepresentatives";
-const PERSON_REQUESTS = "personRequests";
-const RANKING_POINTS = "rankingPoints";
 const ROUND_TARGET = "roundTarget";
 const SCHEDULE_LIMITS = "scheduleLimits";
 const SCHEDULE_TIMING = "scheduleTiming";
 const SCHEDULING_PROFILE = "schedulingProfile";
-const STATUS_DETAIL = "statusDetail";
-const SUB_ORDER = "subOrder";
 const TALLY = "tally";
-const TIE_FORMAT_MODIFICATIONS = "tieFormatModification";
-const extensionConstants = {
-  APPLIED_POLICIES,
-  AUDIT_POSITION_ACTIONS,
-  CONTEXT,
-  // used to capture, e.g. context in which a venue was added
-  DELEGATED_OUTCOME,
-  DISABLED,
-  DISABLE_LINKS,
-  DISABLE_AUTO_CALC,
-  DRAW_DELETIONS,
-  DRAW_PROFILE,
-  ENTRY_PROFILE,
-  // used for drawGeneration; not relevant for anonymized tournaments
-  EVENT_PROFILE,
-  FLIGHT_PROFILE,
-  GROUPING_ATTRIBUTE,
-  // for generating teams; not relevant for anonymized tournaments
-  LINEUPS,
-  LINKED_TOURNAMENTS,
-  MATCHUP_HISTORY,
-  PARTICIPANT_REPRESENTATIVES,
-  PERSON_REQUESTS,
-  RANKING_POINTS,
-  // for attaching points awarded to tournamentRecord
-  ROUND_TARGET,
-  SCHEDULE_LIMITS,
-  SCHEDULE_TIMING,
-  SCHEDULING_PROFILE,
-  STATUS_DETAIL,
-  // attached to event.entries
-  SUB_ORDER,
-  TALLY,
-  TIE_FORMAT_MODIFICATIONS,
-  // for auditing, not important when anonymized
-  FACTORY
-  // used for capturing versioning of factory and other TODS document processors
-};
 
 function getAppliedPolicies({
   onlySpecifiedPolicyTypes = false,
@@ -976,7 +907,7 @@ function getPolicyDefinitions({
     if (policy)
       policyDefinitions[policyType] = policy;
   }
-  return Object.keys(policyDefinitions).length ? { policyDefinitions } : { error: POLICY_NOT_FOUND };
+  return Object.keys(policyDefinitions).length ? { policyDefinitions } : { info: POLICY_NOT_FOUND.message };
 }
 
 const RANKING = "RANKING";
@@ -1723,7 +1654,7 @@ function findPolicy({
     structure,
     event
   });
-  return appliedPolicies?.[policyType] ? { policy: appliedPolicies[policyType] } : { error: POLICY_NOT_FOUND };
+  return appliedPolicies?.[policyType] ? { policy: appliedPolicies[policyType] } : { info: POLICY_NOT_FOUND?.message };
 }
 
 function getScheduleTiming({
@@ -5812,7 +5743,6 @@ function matchUpEndTime({ matchUp }) {
 
 const SINGLES = "SINGLES";
 const TEAM = "TEAM";
-const TEAM_EVENT = "TEAM";
 
 function getMatchUpScheduleDetails({
   scheduleVisibilityFilters,
@@ -8791,6 +8721,199 @@ function getMatchUpFormatTimingUpdate({ tournamentRecords }) {
   });
 }
 
+const FORMAT_STANDARD = "SET3-S:6/TB7";
+
+const ADULT = "ADULT";
+const JUNIOR = "JUNIOR";
+const WHEELCHAIR = "WHEELCHAIR";
+const POLICY_SCHEDULING_DEFAULT = {
+  [POLICY_TYPE_SCHEDULING]: {
+    defaultTimes: {
+      averageTimes: [{ categoryNames: [], minutes: { default: 90 } }],
+      recoveryTimes: [{ minutes: { [DOUBLES]: 30, default: 60 } }]
+    },
+    defaultDailyLimits: {
+      [SINGLES$1]: 2,
+      [DOUBLES]: 2,
+      total: 3
+    },
+    matchUpAverageTimes: [
+      {
+        matchUpFormatCodes: [FORMAT_STANDARD],
+        // Best of 3 tiebreak sets
+        averageTimes: [
+          {
+            categoryNames: [],
+            minutes: { default: 90 }
+          },
+          {
+            categoryTypes: [WHEELCHAIR],
+            minutes: { default: 120 }
+          }
+        ]
+      },
+      {
+        matchUpFormatCodes: ["SET3-S:6/TB7-F:TB10"],
+        // Two tiebreak sets, 10-point match tiebreak at one set all
+        averageTimes: [{ categoryNames: [], minutes: { default: 85 } }]
+      },
+      {
+        matchUpFormatCodes: ["SET3-S:6/TB7-F:TB7"],
+        // Two tiebreak sets, 7-point match tiebreak at one set all
+        averageTimes: [{ categoryNames: [], minutes: { default: 70 } }]
+      },
+      {
+        matchUpFormatCodes: ["SET3-S:4NOAD-F:TB7"],
+        // Two short sets to 4 with deciding game at 3-3, 7-point match tiebreak at one set all
+        averageTimes: [{ categoryNames: [], minutes: { default: 55 } }]
+      },
+      {
+        matchUpFormatCodes: ["SET3-S:4/TB7"],
+        // Best of 3 sets to 4
+        averageTimes: [{ categoryNames: [], minutes: { default: 60 } }]
+      },
+      {
+        matchUpFormatCodes: ["SET3-S:4/TB7-F:TB7"],
+        // Two short sets to 4, 7-point match tiebreak at one set all
+        averageTimes: [{ categoryNames: [], minutes: { default: 50 } }]
+      },
+      {
+        matchUpFormatCodes: ["SET3-S:4/TB7-F:TB10"],
+        // Two short sets to 4, 10-point match tiebreak at one set all
+        averageTimes: [{ categoryNames: [], minutes: { default: 55 } }]
+      },
+      {
+        matchUpFormatCodes: ["SET3-S:4/TB5@3"],
+        // Two out of three short sets to 4 with 5-point tiebreak at 3 games all
+        averageTimes: [{ categoryNames: [], minutes: { default: 45 } }]
+      },
+      {
+        matchUpFormatCodes: [
+          "SET1-S:8/TB7",
+          "SET1-S:8/TB7@7"
+        ],
+        averageTimes: [{ categoryNames: [], minutes: { default: 40 } }]
+      },
+      {
+        matchUpFormatCodes: ["SET1-S:5/TB9@4"],
+        // One no advantage set to 5, tiebreak to 9 at 4-4
+        averageTimes: [{ categoryNames: [], minutes: { default: 30 } }]
+      },
+      {
+        matchUpFormatCodes: ["SET1-S:6/TB7"],
+        // One standard tiebreak set to 6, 7-point tiebreak at 6 games all
+        averageTimes: [{ categoryNames: [], minutes: { default: 30 } }]
+      },
+      {
+        matchUpFormatCodes: ["SET1-S:6NOAD"],
+        // One set to 6 with deciding game at 5 games all
+        averageTimes: [{ categoryNames: [], minutes: { default: 30 } }]
+      },
+      {
+        matchUpFormatCodes: [
+          "SET1-S:4/TB7",
+          "SET1-S:4/TB5@3",
+          "SET3-S:TB10",
+          "SET1-S:T20"
+        ],
+        averageTimes: [{ categoryNames: [], minutes: { default: 20 } }]
+      },
+      {
+        matchUpFormatCodes: ["SET1-S:4NOAD"],
+        // One short set to 4, deciding game is played at 3 games all
+        averageTimes: [{ categoryNames: [], minutes: { default: 20 } }]
+      },
+      {
+        matchUpFormatCodes: ["SET1-S:TB10"],
+        // One 10-point tiebreak game
+        averageTimes: [{ categoryNames: [], minutes: { default: 10 } }]
+      }
+    ],
+    matchUpRecoveryTimes: [
+      {
+        matchUpFormatCodes: [
+          "SET3-S:6/TB7",
+          "SET3-S:6/TB7-F:TB10",
+          "SET3-S:6/TB7-F:TB7"
+        ],
+        recoveryTimes: [
+          {
+            categoryTypes: [ADULT, WHEELCHAIR],
+            minutes: { default: 60, [DOUBLES]: 30 }
+          },
+          {
+            categoryTypes: [JUNIOR],
+            minutes: { default: 60, [DOUBLES]: 60 }
+          }
+        ]
+      },
+      {
+        matchUpFormatCodes: [
+          "SET3-S:4/TB7-F:TB7",
+          "SET3-S:4/TB7-F:TB10",
+          "SET3-S:4NOAD-F:TB7",
+          "SET3-S:4/TB7",
+          "SET3-S:4/TB5@3"
+        ],
+        recoveryTimes: [
+          {
+            categoryTypes: [ADULT, WHEELCHAIR],
+            minutes: { default: 30 }
+          },
+          {
+            categoryTypes: [JUNIOR],
+            minutes: { default: 60 }
+          }
+        ]
+      },
+      {
+        matchUpFormatCodes: [
+          "SET1-S:8/TB7",
+          "SET1-S:8/TB7@7",
+          "SET1-S:5/TB9@4",
+          "SET1-S:6/TB7",
+          "SET1-S:6NOAD",
+          "SET1-S:4/TB7",
+          "SET1-S:4NOAD",
+          "SET3-S:TB10",
+          "SET1-S:T20"
+        ],
+        recoveryTimes: [
+          {
+            categoryNames: [],
+            minutes: { default: 30 }
+          }
+        ]
+      },
+      {
+        matchUpFormatCodes: ["SET1-S:4/TB5@3"],
+        // One short set to 4, 5-point tiebreak at 3 games all
+        recoveryTimes: [
+          {
+            categoryTypes: [ADULT, JUNIOR],
+            minutes: { default: 30 }
+          },
+          {
+            categoryTypes: [WHEELCHAIR],
+            minutes: { default: 15 }
+          }
+        ]
+      },
+      {
+        matchUpFormatCodes: ["SET1-S:TB10"],
+        // One 10-point tiebreak game
+        recoveryTimes: [
+          {
+            categoryNames: [],
+            minutes: { default: 15 }
+          }
+        ]
+      }
+    ],
+    matchUpDailyLimits: []
+  }
+};
+
 function getEventMatchUpFormatTiming$1({
   tournamentRecord,
   matchUpFormats,
@@ -8804,6 +8927,7 @@ function getEventMatchUpFormatTiming$1({
   if (!event)
     return { error: MISSING_EVENT };
   let matchUpFormatDefinitions = [];
+  let info;
   if (!matchUpFormats?.length) {
     const { policy } = findPolicy({
       policyType: POLICY_TYPE_SCORING,
@@ -8817,20 +8941,19 @@ function getEventMatchUpFormatTiming$1({
         name: SCHEDULE_TIMING,
         event
       });
+      let matchUpAverageTimes, matchUpRecoveryTimes;
       if (extension?.value) {
-        matchUpFormatDefinitions = unique(
-          [
-            ...(extension.value.matchUpAverageTimes || []).map(
-              (at) => at.matchUpFormatCodes
-            ),
-            ...(extension.value.matchUpRecoveryTimes || []).map(
-              (at) => at.matchUpFormatCodes
-            )
-          ].flat()
-        ).map((matchUpFormat) => ({ matchUpFormat }));
+        ({ matchUpAverageTimes, matchUpRecoveryTimes } = extension.value);
       } else {
-        return { error: MISSING_SCORING_POLICY };
+        ({ matchUpAverageTimes, matchUpRecoveryTimes } = POLICY_SCHEDULING_DEFAULT[POLICY_TYPE_SCHEDULING]);
       }
+      matchUpFormatDefinitions = unique(
+        [
+          ...(matchUpAverageTimes || []).map((at) => at.matchUpFormatCodes),
+          ...(matchUpRecoveryTimes || []).map((at) => at.matchUpFormatCodes)
+        ].flat()
+      ).map((matchUpFormat) => ({ matchUpFormat }));
+      info = "default scheduling policy in use";
     }
   } else {
     const uniqueMatchUpFormats = [];
@@ -8845,7 +8968,7 @@ function getEventMatchUpFormatTiming$1({
     }).filter(Boolean);
   }
   const { eventType, eventId, category } = event;
-  const categoryName = category?.categoryName || category?.ageCategoryCode || eventId;
+  const categoryName = category?.categoryName ?? category?.ageCategoryCode ?? eventId;
   if (!eventId)
     return { error: MISSING_EVENT };
   const eventMatchUpFormatTiming = matchUpFormatDefinitions.map(
@@ -8858,17 +8981,14 @@ function getEventMatchUpFormatTiming$1({
         eventType,
         event
       });
-      return Object.assign(
-        {},
-        {
-          ...timing,
-          description,
-          matchUpFormat
-        }
-      );
+      return {
+        matchUpFormat,
+        description,
+        ...timing
+      };
     }
   );
-  return { eventMatchUpFormatTiming };
+  return definedAttributes({ eventMatchUpFormatTiming, info });
 }
 
 function getEventMatchUpFormatTiming({
@@ -11248,7 +11368,7 @@ function participantScaleItem({
     return { error: INVALID_VALUES };
   if (!participant.timeItems)
     participant.timeItems = [];
-  if (participant && Array.isArray(participant.timeItems)) {
+  if (Array.isArray(participant.timeItems)) {
     const { accessor, scaleType, eventType, scaleName } = scaleAttributes;
     const filterType = [SCALE, scaleType, eventType, scaleName].join(".");
     const filteredTimeItems = participant.timeItems.filter((timeItem2) => timeItem2?.itemType === filterType).filter((timeItem2) => !requireTimeStamp || timeItem2?.itemDate).sort(
@@ -11268,12 +11388,10 @@ function participantScaleItem({
         scaleName: scaleName2,
         scaleType: scaleType2
       };
-      return { scaleItem };
-    } else {
-      return { error: SCALE_ITEM_NOT_FOUND };
+      return { ...SUCCESS, scaleItem };
     }
   }
-  return { error: MISSING_PARTICIPANT };
+  return { ...SUCCESS, scaleItem: void 0 };
 }
 
 function addFinishingRounds({
@@ -11838,7 +11956,7 @@ function addStructureParticipation({
 
 function processSides(params) {
   const {
-    withScheduleTimes,
+    withScheduleItems,
     scheduleAnalysis,
     withTeamMatchUps,
     participantMap,
@@ -11948,7 +12066,7 @@ function processSides(params) {
           stage
         });
       }
-      if (scheduleAnalysis || withScheduleTimes) {
+      if (scheduleAnalysis || withScheduleItems) {
         addScheduleItem({
           participantMap,
           participantId: participantId2,
@@ -12094,7 +12212,6 @@ function getParticipantEntries(params) {
     participantMap,
     withPotentialMatchUps,
     withRankingProfile,
-    withScheduleTimes,
     withScheduleItems,
     scheduleAnalysis,
     withTeamMatchUps,
@@ -12105,8 +12222,6 @@ function getParticipantEntries(params) {
     withEvents,
     withDraws
   } = params;
-  if (withScheduleItems)
-    console.log({ withScheduleItems });
   const targetParticipantIds = participantFilters?.participantIds;
   const getRelevantParticipantIds = (participantId) => {
     const relevantParticipantIds = [participantId];
@@ -12124,7 +12239,7 @@ function getParticipantEntries(params) {
     withDraws: withDraws || withRankingProfile,
     withPotentialMatchUps,
     withRankingProfile,
-    withScheduleTimes,
+    withScheduleItems,
     scheduleAnalysis,
     withTeamMatchUps,
     withStatistics,
@@ -12444,7 +12559,7 @@ function getParticipantEntries(params) {
             matchUpType: matchUpType2
           });
         }
-        if (Array.isArray(potentialParticipants) && (nextMatchUps || !!scheduleAnalysis || withScheduleTimes)) {
+        if (Array.isArray(potentialParticipants) && (nextMatchUps || !!scheduleAnalysis || withScheduleItems)) {
           const potentialParticipantIds = potentialParticipants.flat().map(extractAttributes("participantId")).filter(Boolean);
           potentialParticipantIds?.forEach((participantId) => {
             const relevantParticipantIds = getRelevantParticipantIds(participantId);
@@ -12459,7 +12574,7 @@ function getParticipantEntries(params) {
                 drawId
               });
             });
-            if (!!scheduleAnalysis || withScheduleTimes) {
+            if (!!scheduleAnalysis || withScheduleItems) {
               addScheduleItem({
                 potential: true,
                 participantMap,
@@ -12568,13 +12683,18 @@ function getParticipantEntries(params) {
             const notBeforeTime = typeChange ? typeChangeTimeAfterRecovery || timeAfterRecovery : timeAfterRecovery;
             const sameDraw = scheduleItem.drawId === consideredItem.drawId;
             const bothPotential = potentialMatchUps[scheduleItem.matchUpId] && potentialMatchUps[consideredItem.matchUpId];
-            const nextMinutes = timeStringMinutes(consideredItem.scheduledTime);
-            const minutesDifference = Math.abs(nextMinutes - scheduledMinutes);
-            const timeOverlap = scheduledMinutesDifference && !isNaN(scheduledMinutesDifference) ? minutesDifference <= scheduledMinutesDifference : timeStringMinutes(notBeforeTime) > timeStringMinutes(consideredItem.scheduledTime);
-            if (timeOverlap && !(bothPotential && sameDraw)) {
+            const consideredMinutes = timeStringMinutes(
+              consideredItem.scheduledTime
+            );
+            const minutesDifference = Math.abs(
+              consideredMinutes - scheduledMinutes
+            );
+            const itemIsPrior = consideredMinutes > scheduledMinutes;
+            const timeOverlap = scheduledMinutesDifference && !isNaN(scheduledMinutesDifference) ? minutesDifference <= scheduledMinutesDifference : itemIsPrior && timeStringMinutes(consideredItem.scheduledTime) < timeStringMinutes(notBeforeTime);
+            if (timeOverlap && !(bothPotential && sameDraw) && itemIsPrior) {
               participantAggregator.scheduleConflicts.push({
-                priorScheduledMatchUpId: consideredItem.matchUpId,
-                matchUpIdWithConflict: scheduleItem.matchUpId
+                priorScheduledMatchUpId: scheduleItem.matchUpId,
+                matchUpIdWithConflict: consideredItem.matchUpId
               });
             }
           }
@@ -12673,6 +12793,7 @@ function getParticipants(params) {
     ({
       potentialMatchUps,
       scheduleConflicts,
+      scheduleItems,
       participant,
       statistics,
       opponents,
@@ -12698,7 +12819,8 @@ function getParticipants(params) {
           matchUps: withMatchUps || withRankingProfile ? Object.values(matchUps2) : void 0,
           opponents: withOpponents ? participantOpponents : void 0,
           potentialMatchUps: nextMatchUps ? Object.values(potentialMatchUps) : void 0,
-          statistics: withStatistics ? Object.values(statistics) : void 0
+          statistics: withStatistics ? Object.values(statistics) : void 0,
+          scheduleItems: withScheduleItems ? scheduleItems : void 0
         },
         false,
         false,
@@ -12729,1108 +12851,6 @@ function getParticipants(params) {
   };
 }
 
-function getDerivedPositionAssignments({
-  derivedDrawInfo,
-  participantId,
-  drawId
-}) {
-  const mainPositionAssignment = derivedDrawInfo[drawId]?.mainPositionAssignments?.find(
-    (assignment) => assignment.participantId === participantId
-  );
-  const qualifyingPositionAssignment = derivedDrawInfo[drawId]?.qualifyingPositionAssignments?.find(
-    (assignment) => assignment.participantId === participantId
-  );
-  const positionAssignments = {};
-  if (mainPositionAssignment) {
-    const { participantId: participantId2, ...props } = mainPositionAssignment;
-    if (participantId2)
-      positionAssignments[MAIN] = { ...props };
-  }
-  if (qualifyingPositionAssignment) {
-    const { participantId: participantId2, ...props } = qualifyingPositionAssignment;
-    if (participantId2)
-      positionAssignments[QUALIFYING] = { ...props };
-  }
-  return Object.keys(positionAssignments).length ? positionAssignments : void 0;
-}
-
-function getRelevantParticipantIdsMap({
-  processParticipantId,
-  // optional method which is passed each participantId
-  tournamentRecords,
-  tournamentRecord
-}) {
-  if (typeof tournamentRecord !== "object" && typeof tournamentRecords !== "object")
-    return { error: MISSING_TOURNAMENT_RECORD };
-  const allParticipants = tournamentRecords ? Object.values(tournamentRecords).map((tournamentRecord2) => tournamentRecord2?.participants || []).flat() : tournamentRecord?.participants || [];
-  const relevantParticipantIdsMap = Object.assign(
-    {},
-    ...allParticipants.map(
-      ({ participantId, participantType, individualParticipantIds }) => {
-        typeof processParticipantId === "function" && processParticipantId(participantId);
-        const individualParticipantIdObjects = (individualParticipantIds || []).map((relevantParticipantId) => ({
-          participantType: INDIVIDUAL,
-          relevantParticipantId
-        }));
-        return {
-          [participantId]: individualParticipantIdObjects.concat({
-            relevantParticipantId: participantId,
-            participantType
-          })
-        };
-      }
-    )
-  );
-  return { relevantParticipantIdsMap };
-}
-
-function getDerivedSeedAssignments({
-  derivedDrawInfo,
-  participantId,
-  drawId
-}) {
-  const mainSeedAssignment = derivedDrawInfo[drawId]?.mainSeedAssignments?.find(
-    (assignment) => assignment.participantId === participantId
-  );
-  const qualifyingSeedAssignment = derivedDrawInfo[drawId]?.qualifyingSeedAssignments?.find(
-    (assignment) => assignment.participantId === participantId
-  );
-  const seedAssignments = {};
-  if (mainSeedAssignment) {
-    const { participantId: participantId2, ...props } = mainSeedAssignment;
-    if (participantId2)
-      seedAssignments[MAIN] = { ...props };
-  }
-  if (qualifyingSeedAssignment) {
-    const { participantId: participantId2, ...props } = qualifyingSeedAssignment;
-    if (participantId2)
-      seedAssignments[QUALIFYING] = { ...props };
-  }
-  return Object.keys(seedAssignments).length ? seedAssignments : void 0;
-}
-
-const hasSchedule = ({
-  scheduleAttributes = ["scheduledDate", "scheduledTime"],
-  schedule = {}
-}) => {
-  const matchUpScheduleKeys = Object.keys(schedule).filter((key) => scheduleAttributes.includes(key)).filter((key) => schedule[key]);
-  return !!matchUpScheduleKeys.length;
-};
-
-function participantScheduledMatchUps({
-  scheduleAttributes = ["scheduledDate", "scheduledTime"],
-  matchUps = []
-}) {
-  if (!validMatchUps(matchUps))
-    return { error: MISSING_MATCHUPS };
-  if (!Array.isArray(scheduleAttributes))
-    return { error: INVALID_VALUES };
-  const scheduledMatchUps = matchUps.filter(Boolean).filter(({ schedule }) => hasSchedule({ schedule, scheduleAttributes })).reduce((dateMatchUps, matchUp) => {
-    const { schedule } = matchUp;
-    const date = extractDate(schedule?.scheduledDate);
-    const time = extractTime(schedule?.scheduledTime);
-    if (date && time) {
-      if (dateMatchUps[date]) {
-        dateMatchUps[date].push(matchUp);
-      } else {
-        dateMatchUps[date] = [matchUp];
-      }
-    }
-    return dateMatchUps;
-  }, {});
-  const dates = Object.keys(scheduledMatchUps);
-  dates.forEach((date) => {
-    scheduledMatchUps[date].sort(
-      (a, b) => timeSort(
-        extractTime(a.schedule?.scheduledTime),
-        extractTime(b.schedule?.scheduledTime)
-      )
-    );
-  });
-  return { scheduledMatchUps };
-}
-
-function annotateParticipant(params) {
-  const {
-    withScaleValues = true,
-    eventsPublishStatuses,
-    withEvents = true,
-    withDraws = true,
-    participantIdMap,
-    scheduleAnalysis,
-    derivedDrawInfo,
-    usePublishState,
-    withStatistics,
-    withOpponents,
-    withMatchUps,
-    withSeeding,
-    participant,
-    withISO2,
-    withIOC
-  } = params;
-  const scheduleConflicts = [];
-  const scheduleItems = [];
-  if (withIOC || withISO2)
-    addNationalityCode({ participant, withIOC, withISO2 });
-  if (withScaleValues) {
-    const { ratings, rankings } = getScaleValues({ participant });
-    participant.rankings = rankings;
-    participant.ratings = ratings;
-  }
-  const participantId = participant?.participantId;
-  if (!participantId || !participantIdMap[participantId])
-    return {};
-  const {
-    potentialMatchUps,
-    opponents,
-    matchUps,
-    events,
-    losses,
-    draws,
-    wins
-  } = participantIdMap[participantId];
-  const denominator = wins + losses;
-  const numerator = wins;
-  const statValue = denominator && numerator / denominator;
-  const winRatioStat = {
-    statCode: WIN_RATIO,
-    denominator,
-    numerator,
-    statValue
-  };
-  const participantDraws = Object.values(draws);
-  const participantEvents = Object.values(events);
-  if (withDraws && participantDraws) {
-    participant.draws = participantDraws;
-    for (const participantDraw of participantDraws) {
-      const publishedSeeding = eventsPublishStatuses[participantDraw.eventId]?.publishedSeeding;
-      const seedingPublished = !usePublishState || publishedSeeding?.published && (publishedSeeding?.drawIds?.length === 0 || publishedSeeding?.drawIds?.includes(participantDraw.drawId));
-      if (seedingPublished) {
-        const seedAssignments = getDerivedSeedAssignments({
-          drawId: participantDraw.drawId,
-          derivedDrawInfo,
-          participantId
-        });
-        if (seedAssignments) {
-          participantDraw.seedAssignments = seedAssignments;
-        }
-      }
-    }
-  }
-  if (withEvents && participantEvents) {
-    participant.events = participantEvents;
-    if (withSeeding) {
-      const seedingScales = Object.assign(
-        {},
-        ...(participant.timeItems || []).filter(({ itemType }) => itemType.split(".")[1] === SEEDING).map(({ itemType: seedingScaleName, itemValue: seedValue }) => ({
-          [seedingScaleName]: seedValue
-        }))
-      );
-      for (const participantEvent of participantEvents) {
-        const getScaleAccessor = (scaleName) => [SCALE, SEEDING, participantEvent.eventType, scaleName].join(".");
-        const publishedSeeding = eventsPublishStatuses[participantEvent.eventId]?.publishedSeeding;
-        const eventSeedingScaleNames = (publishedSeeding?.stageSeedingScaleNames && Object.values(publishedSeeding?.stageSeedingScaleNames) || Array.isArray(publishedSeeding?.seedingScaleNames) && publishedSeeding.seedingScaleNames || []).map(getScaleAccessor);
-        const publishedEventSeedingScaleNames = intersection(
-          Object.keys(seedingScales),
-          eventSeedingScaleNames
-        );
-        const eventSeedingPublished = !!(!usePublishState || !Object.keys(seedingScales).length && !publishedSeeding?.drawIds?.length || publishedEventSeedingScaleNames.length);
-        if (eventSeedingPublished && publishedEventSeedingScaleNames.length) {
-          if (publishedSeeding?.stageSeedingScaleNames) {
-            const scaleValues = Object.keys(
-              publishedSeeding.stageSeedingScaleNames
-            ).map((key) => {
-              const accessor = getScaleAccessor(
-                publishedSeeding.stageSeedingScaleNames[key]
-              );
-              const scaleValue = seedingScales[accessor];
-              return [key, scaleValue];
-            }).filter((pair) => pair[1]).map((pair) => ({ [pair[0]]: { seedValue: pair[1] } }));
-            const seedAssignments = Object.assign({}, ...scaleValues);
-            participantEvent.seedAssignments = seedAssignments;
-          } else if (publishedEventSeedingScaleNames) {
-            const seedValues = publishedEventSeedingScaleNames.map(
-              (scaleName) => seedingScales[scaleName]
-            );
-            participantEvent.seedValue = seedValues.pop();
-          }
-        } else if (!usePublishState && typeof withSeeding === "object") {
-          const scaleValues = Object.keys(withSeeding).map((key) => {
-            const accessor = getScaleAccessor(withSeeding[key]);
-            const scaleValue = seedingScales[accessor];
-            return [key, scaleValue];
-          }).filter((pair) => pair[1]).map((pair) => ({ [pair[0]]: { seedValue: pair[1] } }));
-          const seedAssignments = Object.assign({}, ...scaleValues);
-          participantEvent.seedAssignments = seedAssignments;
-        } else {
-          const { categoryName, ageCategoryCode } = participantEvent.category || {};
-          let scaleItem;
-          for (const scaleName of [
-            participantEvent.eventId,
-            ageCategoryCode,
-            categoryName
-          ]) {
-            const scaleAttributes = {
-              eventType: participantEvent.eventType,
-              scaleType: SEEDING,
-              scaleName
-            };
-            const result = participantScaleItem({
-              scaleAttributes,
-              participant
-            });
-            if (result.scaleItem) {
-              scaleItem = result.scaleItem;
-              break;
-            }
-          }
-          if (scaleItem) {
-            const seedValue = scaleItem.scaleValue;
-            const seedingPublished = !usePublishState || publishedSeeding?.published && (publishedSeeding?.drawIds?.length === 0 || publishedSeeding?.drawIds?.includes(
-              participantEvent.drawId
-            ));
-            if (seedingPublished) {
-              participantEvent.seedValue = seedValue;
-            }
-          }
-        }
-        if (participantEvent.drawIds?.length) {
-          for (const flightDrawId of participantEvent.drawIds || []) {
-            const drawSeedPublishingDisabled = publishedSeeding?.drawIds?.length && !publishedSeeding?.drawIds?.includes(flightDrawId);
-            if (eventSeedingPublished && !drawSeedPublishingDisabled) {
-              const seedAssignments = getDerivedSeedAssignments({
-                drawId: flightDrawId,
-                derivedDrawInfo,
-                participantId
-              });
-              if (seedAssignments && participantEvent.seedAssignments) {
-                for (const key of Object.keys(
-                  participantEvent.seedAssignments
-                )) {
-                  participantEvent.seedAssignments[key] = seedAssignments[key];
-                }
-              } else {
-                participantEvent.seedAssignments = seedAssignments;
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  const participantOpponents = Object.values(opponents).flat();
-  if (withOpponents && participantOpponents?.length) {
-    participant.opponents = participantOpponents;
-    participantDraws?.forEach((draw) => {
-      draw.opponents = participantOpponents.filter(
-        (opponent) => opponent.drawId === draw.drawId
-      );
-    });
-  }
-  const participantPotentialMatchUps = Object.values(potentialMatchUps);
-  const participantMatchUps = Object.values(matchUps);
-  if (withMatchUps) {
-    participant.potentialMatchUps = participantPotentialMatchUps;
-    participant.matchUps = participantMatchUps;
-  }
-  const allParticipantMatchUps = participantMatchUps.concat(
-    participantPotentialMatchUps
-  );
-  const scheduledMatchUps = participantScheduledMatchUps({
-    matchUps: allParticipantMatchUps
-  })?.scheduledMatchUps || [];
-  const { scheduledMinutesDifference } = scheduleAnalysis || {};
-  const dates = Object.keys(scheduledMatchUps);
-  dates.forEach((date) => {
-    scheduledMatchUps[date].filter(Boolean).forEach((matchUp, i) => {
-      const {
-        schedule: {
-          scheduledTime,
-          timeAfterRecovery,
-          typeChangeTimeAfterRecovery
-        },
-        matchUpStatus,
-        roundPosition,
-        structureName,
-        matchUpType,
-        roundNumber,
-        matchUpId,
-        drawId,
-        score
-      } = matchUp;
-      scheduleItems.push({
-        ...matchUp.schedule,
-        scheduledTime: extractTime(matchUp.schedule?.scheduledTime),
-        roundPosition,
-        structureName,
-        matchUpType,
-        roundNumber,
-        matchUpId,
-        drawId
-      });
-      const ignoreMatchUp = matchUpStatus === BYE || [WALKOVER$1, DEFAULTED].includes(matchUpStatus) && !scoreHasValue({ score });
-      if (scheduledTime && !ignoreMatchUp) {
-        const scheduledMinutes = timeStringMinutes(scheduledTime);
-        const matchUpsToConsider = scheduledMatchUps[date].slice(i + 1);
-        for (const consideredMatchUp of matchUpsToConsider) {
-          const ignoreMatchUp2 = consideredMatchUp.matchUpStatus === BYE || [WALKOVER$1, DEFAULTED].includes(consideredMatchUp.matchUpStatus) && !scoreHasValue(consideredMatchUp);
-          if (!ignoreMatchUp2 && consideredMatchUp.schedule?.scheduledTime) {
-            const typeChange = matchUp.matchUpType !== consideredMatchUp.matchUpType;
-            const notBeforeTime = typeChange ? typeChangeTimeAfterRecovery || timeAfterRecovery : timeAfterRecovery;
-            const sameDraw = matchUp.drawId === consideredMatchUp.drawId;
-            const bothPotential = matchUp.potential && consideredMatchUp.potential;
-            const nextMinutes = timeStringMinutes(
-              consideredMatchUp.schedule?.scheduledTime
-            );
-            const minutesDifference = nextMinutes - scheduledMinutes;
-            const timeOverlap = scheduledMinutesDifference && !isNaN(scheduledMinutesDifference) ? minutesDifference <= scheduledMinutesDifference : timeStringMinutes(notBeforeTime) > timeStringMinutes(consideredMatchUp.schedule?.scheduledTime);
-            if (timeOverlap && !(bothPotential && sameDraw)) {
-              scheduleConflicts.push({
-                priorScheduledMatchUpId: consideredMatchUp.matchUpId,
-                matchUpIdWithConflict: matchUpId
-              });
-            }
-          }
-        }
-      }
-    });
-  });
-  if (withStatistics)
-    participant.statistics = [winRatioStat];
-  return { scheduleConflicts, scheduleItems };
-}
-
-function getDrawDetails({
-  eventEntries,
-  sortConfig,
-  event
-}) {
-  const derivedInfo = {};
-  const drawDetails = Object.assign(
-    {},
-    ...(event.drawDefinitions ?? []).map((drawDefinition) => {
-      const entriesMap = Object.assign(
-        {},
-        ...(eventEntries ?? []).filter((entry) => entry.participantId).map((entry) => ({ [entry.participantId]: entry })),
-        ...drawDefinition.entries.filter((entry) => entry.participantId).map((entry) => ({ [entry.participantId]: entry }))
-      );
-      const drawEntries = Object.values(entriesMap);
-      const mainStructure = getDrawStructures({
-        stageSequence: 1,
-        drawDefinition,
-        stage: MAIN
-      })?.structures?.[0];
-      const mainPositionAssignments = mainStructure && getPositionAssignments({
-        structure: mainStructure
-      })?.positionAssignments;
-      const drawSize = mainPositionAssignments?.length;
-      const qualifyingStructure = getDrawStructures({
-        stageSequence: 1,
-        stage: QUALIFYING,
-        drawDefinition
-      })?.structures?.[0];
-      const qualifyingPositionAssignments = mainStructure && getPositionAssignments({
-        structure: qualifyingStructure
-      })?.positionAssignments;
-      const qualifyingDrawSize = qualifyingPositionAssignments?.length;
-      const mainSeedAssignments = mainStructure?.seedAssignments;
-      const qualifyingSeedAssignments = qualifyingStructure?.seedAssignments;
-      const orderedStructureIds = (drawDefinition.structures || []).sort((a, b) => structureSort(a, b, sortConfig)).map(({ structureId, structures }) => {
-        return [
-          structureId,
-          ...(structures || []).map(({ structureId: structureId2 }) => structureId2)
-        ];
-      }).flat(Infinity);
-      const flightNumber = event?._flightProfile?.flights?.find(
-        (flight) => flight.drawId === drawDefinition.drawId
-      )?.flightNumber;
-      derivedInfo[drawDefinition.drawId] = {
-        qualifyingPositionAssignments,
-        qualifyingSeedAssignments,
-        mainPositionAssignments,
-        mainSeedAssignments,
-        orderedStructureIds,
-        qualifyingDrawSize,
-        flightNumber,
-        drawSize
-      };
-      return {
-        [drawDefinition.drawId]: {
-          drawType: drawDefinition.drawType,
-          drawEntries
-        }
-      };
-    })
-  );
-  return { derivedInfo, drawDetails };
-}
-
-function processMatchUp({
-  relevantParticipantIdsMap,
-  participantFilters,
-  participantIdMap,
-  derivedDrawInfo,
-  eventDrawsCount,
-  drawDetails,
-  eventType,
-  matchUp
-}) {
-  const {
-    collectionId,
-    collectionPosition,
-    drawId,
-    drawName,
-    eventId,
-    eventName,
-    finishingRound,
-    finishingPositionRange,
-    processCodes,
-    loserTo,
-    matchUpId,
-    matchUpType,
-    matchUpFormat,
-    matchUpStatus,
-    matchUpStatusCodes,
-    matchUpTieId,
-    roundName,
-    roundNumber,
-    roundPosition,
-    score,
-    sides,
-    stage,
-    stageSequence,
-    schedule,
-    structureName,
-    structureId,
-    tieFormat,
-    tieMatchUps,
-    tournamentId,
-    winnerTo,
-    winningSide
-  } = matchUp;
-  const targetParticipantIds = participantFilters?.participantIds;
-  const getRelevantParticipantIds = (participantId) => {
-    const relevantParticipantIds = participantId && relevantParticipantIdsMap[participantId] || [];
-    relevantParticipantIds.push(participantId);
-    return relevantParticipantIds.some(
-      (obj) => !targetParticipantIds || targetParticipantIds.includes(obj.relevantParticipantId)
-    ) ? relevantParticipantIds : [];
-  };
-  const { winner, loser } = finishingPositionRange || {};
-  const doublesTieParticipants = tieMatchUps?.length && tieMatchUps.filter(({ matchUpType: matchUpType2 }) => matchUpType2 === DOUBLES_MATCHUP).map(
-    ({ sides: sides2 }) => sides2.map(
-      ({ sideNumber, participantId, participant }) => sideNumber && participantId && {
-        sideNumber,
-        participantId,
-        participant
-      }
-    )
-  ).flat().filter(Boolean) || [];
-  if (eventType === TEAM_EVENT && matchUpType === DOUBLES_MATCHUP) {
-    const participants = (matchUp.sides?.filter(Boolean) || []).map(
-      ({ sideNumber, participantId, participant }) => sideNumber && participantId && {
-        sideNumber,
-        participantId,
-        participant
-      }
-    ).filter(Boolean);
-    doublesTieParticipants.push(...participants);
-  }
-  sides?.forEach((params) => {
-    const { participantId, sideNumber } = params;
-    if (!participantId)
-      return;
-    const { drawType, drawEntries } = drawDetails[drawId];
-    const participantScore = sideNumber === 1 ? score?.scoreStringSide1 : score?.scoreStringSide2;
-    const participantWon = winningSide && sideNumber === winningSide;
-    const opponent = matchUp.sides.find(
-      (side) => side.sideNumber === 3 - sideNumber
-    );
-    const opponentParticipantId = opponent?.participantId;
-    const relevantOpponents = opponentParticipantId && relevantParticipantIdsMap[opponentParticipantId] || [];
-    const finishingPositionRange2 = participantWon ? winner : loser;
-    const drawEntry = drawEntries.find(
-      (entry) => entry.participantId === participantId
-    );
-    const relevantParticipantIds = getRelevantParticipantIds(participantId);
-    const addedPairParticipantIds = [];
-    doublesTieParticipants?.filter((participant) => participant.sideNumber === sideNumber).forEach((p) => {
-      const participantId2 = p.participantId;
-      if (participantId2 && !addedPairParticipantIds.includes(participantId2)) {
-        relevantParticipantIds.push({
-          relevantParticipantId: participantId2,
-          participantType: PAIR
-        });
-        addedPairParticipantIds.push(participantId2);
-      }
-    });
-    const filteredRelevantParticipantIds = relevantParticipantIds.filter(
-      (opponent2) => {
-        return eventType !== TEAM_EVENT || eventType === TEAM_EVENT && [DOUBLES_MATCHUP, TEAM_MATCHUP].includes(matchUpType) && [PAIR, TEAM_PARTICIPANT].includes(opponent2.participantType) || eventType === TEAM_EVENT && [SINGLES_MATCHUP, DOUBLES_MATCHUP].includes(matchUpType) && [INDIVIDUAL].includes(opponent2.participantType);
-      }
-    );
-    filteredRelevantParticipantIds?.forEach(
-      ({ relevantParticipantId, participantType }) => {
-        const { entryStage, entryStatus, entryPosition } = drawEntry || {};
-        if (!participantIdMap[relevantParticipantId])
-          return;
-        if (!participantIdMap[relevantParticipantId].draws[drawId]) {
-          const positionAssignments = getDerivedPositionAssignments({
-            participantId: relevantParticipantId,
-            derivedDrawInfo,
-            drawId
-          });
-          const seedAssignments = getDerivedSeedAssignments({
-            participantId: relevantParticipantId,
-            derivedDrawInfo,
-            drawId
-          });
-          participantIdMap[relevantParticipantId].draws[drawId] = definedAttributes({
-            qualifyingDrawSize: derivedDrawInfo[drawId]?.qualifyingDrawSize,
-            drawSize: derivedDrawInfo[drawId]?.drawSize,
-            partnerParticipantIds: [],
-            positionAssignments,
-            seedAssignments,
-            entryPosition,
-            entryStatus,
-            entryStage,
-            drawName,
-            drawType,
-            eventId,
-            drawId
-          });
-        }
-        if (!participantIdMap[relevantParticipantId].events[eventId]) {
-          participantIdMap[relevantParticipantId].events[eventId] = {
-            partnerParticipantIds: [],
-            drawIds: [],
-            eventName,
-            eventId
-          };
-        }
-        const eventDrawIds = participantIdMap[relevantParticipantId].events[eventId].drawIds;
-        if (eventDrawIds && !eventDrawIds?.includes(drawId)) {
-          participantIdMap[relevantParticipantId].events[eventId].drawIds.push(
-            drawId
-          );
-        }
-        let partnerParticipantId;
-        if (participantType === INDIVIDUAL && matchUpType === DOUBLES_MATCHUP) {
-          const relevantParticipantInfo = filteredRelevantParticipantIds.find(
-            (participantInfo) => {
-              return participantInfo.relevantParticipantId !== relevantParticipantId && participantInfo.participantType === INDIVIDUAL;
-            }
-          );
-          partnerParticipantId = relevantParticipantInfo?.relevantParticipantId;
-        }
-        const filteredRelevantOpponents = relevantOpponents?.filter(
-          (opponent2) => matchUpType === TEAM_MATCHUP && participantType === TEAM_PARTICIPANT && opponent2.participantType === TEAM_PARTICIPANT || matchUpType === SINGLES_MATCHUP && opponent2.participantType === INDIVIDUAL || matchUpType === DOUBLES_MATCHUP && (participantType === INDIVIDUAL ? [INDIVIDUAL, PAIR].includes(opponent2.participantType) : (
-            // for PAIR participants only show PAIR opponenents
-            opponent2.participantType === PAIR
-          ))
-        ) || [];
-        filteredRelevantOpponents.forEach(
-          ({
-            relevantParticipantId: opponentParticipantId2,
-            participantType: opponentParticipantType
-          }) => {
-            if (!participantIdMap[relevantParticipantId].opponents) {
-              participantIdMap[relevantParticipantId].opponents = {};
-            }
-            participantIdMap[relevantParticipantId].opponents[opponentParticipantId2] = {
-              eventId,
-              drawId,
-              matchUpId,
-              participantType: opponentParticipantType,
-              participantId: opponentParticipantId2
-            };
-          }
-        );
-        const opponentParticipantInfo = filteredRelevantOpponents.map(
-          ({ relevantParticipantId: relevantParticipantId2, participantType: participantType2 }) => ({
-            participantId: relevantParticipantId2,
-            participantType: participantType2
-          })
-        );
-        const includeMatchUp = matchUpType !== TEAM_MATCHUP && [INDIVIDUAL, PAIR].includes(participantType) || matchUpType === TEAM_MATCHUP && participantType === TEAM_PARTICIPANT;
-        if (includeMatchUp)
-          participantIdMap[relevantParticipantId].matchUps[matchUpId] = definedAttributes({
-            collectionId,
-            collectionPosition,
-            drawId,
-            eventId,
-            eventType,
-            eventDrawsCount,
-            finishingRound,
-            finishingPositionRange: finishingPositionRange2,
-            loserTo,
-            matchUpId,
-            matchUpType,
-            matchUpFormat,
-            matchUpStatus,
-            matchUpStatusCodes,
-            matchUpTieId,
-            opponentParticipantInfo,
-            participantWon,
-            partnerParticipantId,
-            perspectiveScoreString: participantScore,
-            processCodes,
-            roundName,
-            roundNumber,
-            roundPosition,
-            schedule,
-            score,
-            sides,
-            stage,
-            stageSequence,
-            structureName,
-            structureId,
-            tieFormat,
-            tournamentId,
-            winnerTo,
-            winningSide
-          });
-        if (partnerParticipantId) {
-          participantIdMap[relevantParticipantId].events[eventId].partnerParticipantIds.push(partnerParticipantId);
-          participantIdMap[relevantParticipantId].draws[drawId].partnerParticipantIds.push(partnerParticipantId);
-          participantIdMap[relevantParticipantId].events[eventId].partnerParticipantId = partnerParticipantId;
-          participantIdMap[relevantParticipantId].draws[drawId].partnerParticipantId = partnerParticipantId;
-        }
-        if (winningSide) {
-          if (participantWon) {
-            participantIdMap[relevantParticipantId].wins++;
-          } else {
-            participantIdMap[relevantParticipantId].losses++;
-          }
-        }
-      }
-    );
-  });
-  if (Array.isArray(matchUp.potentialParticipants)) {
-    const potentialParticipantIds = getParticipantIds(
-      matchUp.potentialParticipants.flat()
-    );
-    potentialParticipantIds?.forEach((participantId) => {
-      const relevantParticipantIds = getRelevantParticipantIds(participantId);
-      relevantParticipantIds?.forEach(({ relevantParticipantId }) => {
-        participantIdMap[relevantParticipantId].potentialMatchUps[matchUpId] = definedAttributes({
-          drawId,
-          eventId,
-          eventType,
-          matchUpId,
-          matchUpType,
-          matchUpFormat,
-          roundName,
-          roundNumber,
-          roundPosition,
-          schedule,
-          tieFormat,
-          structureName,
-          tournamentId,
-          potential: true
-        });
-      });
-    });
-  }
-}
-
-function addParticipantContext(params) {
-  const participantIdsWithConflicts = [];
-  const eventsPublishStatuses = {};
-  const derivedDrawInfo = {};
-  const participantIdMap = {};
-  const initializeParticipantId = (participantId) => {
-    if (!participantIdMap[participantId])
-      participantIdMap[participantId] = {
-        groupParticipantIds: [],
-        teamParticipantIds: [],
-        pairParticipantIds: [],
-        potentialMatchUps: {},
-        scheduleItems: [],
-        opponents: {},
-        matchUps: {},
-        events: {},
-        groups: [],
-        teams: [],
-        draws: {},
-        losses: 0,
-        wins: 0
-      };
-  };
-  const { tournamentRecord, participantFilters, allTournamentParticipants } = params;
-  const { relevantParticipantIdsMap } = getRelevantParticipantIdsMap({
-    processParticipantId: initializeParticipantId,
-    tournamentRecord
-  });
-  const targetParticipantIds = participantFilters?.participantIds;
-  const getRelevantParticipantIds = (participantId) => {
-    const relevantParticipantIds = participantId && relevantParticipantIdsMap[participantId] || [];
-    relevantParticipantIds.push(participantId);
-    return relevantParticipantIds.some(
-      (obj) => !targetParticipantIds || targetParticipantIds.includes(obj.relevantParticipantId)
-    ) ? relevantParticipantIds : [];
-  };
-  params.withGroupings && allTournamentParticipants.forEach((participant) => {
-    if (participant.participantType === GROUP) {
-      const groupParticipantId = participant.participantId;
-      participant?.individualParticipantIds?.forEach((participantId) => {
-        if (!participantIdMap[participantId].groupParticipantIds.includes(
-          groupParticipantId
-        )) {
-          participantIdMap[participantId].groupParticipantIds.push(
-            groupParticipantId
-          );
-          participantIdMap[participantId].groups.push({
-            participantRoleResponsibilities: participant.participantRoleResponsibilities,
-            participantOtherName: participant.participantOtherName,
-            participantName: participant.participantName,
-            participantId: participant.participantId
-          });
-        }
-      });
-    }
-    if (participant.participantType === TEAM$1) {
-      const teamParticipantId = participant.participantId;
-      participant?.individualParticipantIds?.forEach((participantId) => {
-        if (!participantIdMap[participantId]?.teamParticipantIds?.includes(
-          teamParticipantId
-        )) {
-          participantIdMap[participantId]?.teamParticipantIds.push(
-            teamParticipantId
-          );
-          participantIdMap[participantId]?.teams.push({
-            participantRoleResponsibilities: participant.participantRoleResponsibilities,
-            participantOtherName: participant.participantOtherName,
-            participantName: participant.participantName,
-            participantId: participant.participantId,
-            teamId: participant.teamId
-          });
-        }
-      });
-    }
-    if (participant.participantType === PAIR) {
-      const pairParticipantId = participant.participantId;
-      participant?.individualParticipantIds?.forEach((participantId) => {
-        if (participantIdMap[participantId] && !participantIdMap[participantId].pairParticipantIds.includes(
-          pairParticipantId
-        )) {
-          participantIdMap[participantId].pairParticipantIds.push(
-            pairParticipantId
-          );
-        }
-      });
-    }
-  });
-  if (params.withMatchUps) {
-    getMatchUpDependencies({ tournamentRecord });
-  }
-  if (params.withScheduleItems || params.scheduleAnalysis || params.withStatistics || params.withOpponents || params.withMatchUps || params.withSeeding || params.withEvents || params.withDraws) {
-    params.tournamentEvents?.forEach((rawEvent) => {
-      const event = makeDeepCopy(rawEvent, true, true);
-      const flightProfile = getFlightProfile({ event }).flightProfile;
-      const eventDrawsCount = flightProfile?.flights?.length || event.drawDefinitions?.length || 0;
-      (event.drawDefinitions || []).forEach((drawDefinition, i) => {
-        if (event?.eventType === TEAM$1) {
-          const { extension } = findExtension$2({
-            element: rawEvent.drawDefinitions[i],
-            // rawEvent because deepCopy has converted extensions
-            name: LINEUPS
-          });
-          if (extension)
-            drawDefinition.extensions = [extension];
-        }
-      });
-      const { eventId, eventName, eventType, category } = event;
-      const eventInfo = { eventId, eventName, eventType, category };
-      const extensionKeys = event && Object.keys(event).filter((key) => key.startsWith("_"));
-      extensionKeys?.forEach(
-        (extensionKey) => eventInfo[extensionKey] = event[extensionKey]
-      );
-      const eventEntries = event.entries || [];
-      const itemType = `${PUBLISH}.${STATUS$1}`;
-      const { timeItem } = getEventTimeItem({
-        itemType,
-        event
-      });
-      if (timeItem?.itemValue?.PUBLIC) {
-        const { drawIds: publishedDrawIds = [], seeding } = timeItem.itemValue.PUBLIC || {};
-        const publishedSeeding = {
-          published: void 0,
-          // seeding can be present for all entries in an event when no flights have been defined
-          seedingScaleNames: [],
-          drawIds: []
-          // seeding can be specific to drawIds
-        };
-        if (seeding)
-          Object.assign(publishedSeeding, timeItem.itemValue.PUBLIC.seeding);
-        eventsPublishStatuses[eventId] = {
-          publishedDrawIds,
-          publishedSeeding
-        };
-      }
-      const disallowedConstants = [
-        ...Object.values(extensionConstants)
-      ];
-      const disallowedKeys = disallowedConstants.map(
-        (constant) => `_${constant}`
-      );
-      const filteredEventInfo = eventInfo && Object.keys(eventInfo).filter((key) => !disallowedKeys.includes(key)).reduce((obj, key) => {
-        obj[key] = eventInfo[key];
-        return obj;
-      }, {});
-      eventEntries?.filter((entry) => entry?.participantId).forEach((entry) => {
-        const { participantId, entryStage, entryStatus, entryPosition } = entry;
-        const relevantParticipantIds = getRelevantParticipantIds(participantId);
-        relevantParticipantIds?.forEach(({ relevantParticipantId }) => {
-          if (!participantIdMap[relevantParticipantId])
-            initializeParticipantId(relevantParticipantId);
-          participantIdMap[relevantParticipantId].events[eventId] = {
-            ...filteredEventInfo,
-            partnerParticipantIds: [],
-            entryPosition,
-            entryStatus,
-            entryStage,
-            drawIds: [],
-            eventId
-          };
-        });
-      });
-      const addDrawData = ({ drawEntry, drawId }) => {
-        const { participantId, entryStage, entryStatus, entryPosition } = drawEntry;
-        const relevantParticipantIds = getRelevantParticipantIds(participantId);
-        relevantParticipantIds?.forEach(({ relevantParticipantId }) => {
-          if (!participantIdMap[relevantParticipantId].events[eventId]) {
-            participantIdMap[relevantParticipantId].events[eventId] = {
-              ...filteredEventInfo,
-              partnerParticipantIds: [],
-              entryPosition,
-              entryStatus,
-              entryStage,
-              drawIds: [],
-              eventId
-            };
-          }
-          if (!participantIdMap[relevantParticipantId].draws[drawId]) {
-            const positionAssignments = getDerivedPositionAssignments({
-              participantId: relevantParticipantId,
-              derivedDrawInfo,
-              drawId
-            });
-            const seedAssignments = getDerivedSeedAssignments({
-              participantId: relevantParticipantId,
-              derivedDrawInfo,
-              drawId
-            });
-            participantIdMap[relevantParticipantId].draws[drawId] = definedAttributes({
-              qualifyingDrawSize: derivedDrawInfo[drawId]?.qualifyingDrawSize,
-              drawSize: derivedDrawInfo[drawId]?.drawSize,
-              partnerParticipantIds: [],
-              positionAssignments,
-              eventDrawsCount,
-              seedAssignments,
-              entryPosition,
-              entryStatus,
-              entryStage,
-              eventId,
-              drawId
-            });
-          }
-          const eventDrawIds = participantIdMap[relevantParticipantId].events[eventId].drawIds;
-          if (eventDrawIds && !eventDrawIds?.includes(drawId)) {
-            participantIdMap[relevantParticipantId].events[eventId].drawIds.push(drawId);
-          }
-        });
-      };
-      const drawIdsWithDefinitions = event.drawDefinitions?.map(({ drawId }) => drawId) || [];
-      eventInfo._flightProfile?.flights?.forEach((flight) => {
-        const { drawId, drawEntries } = flight;
-        if (!drawIdsWithDefinitions.includes(drawId)) {
-          drawEntries?.forEach(
-            (drawEntry) => addDrawData({ drawEntry, drawId })
-          );
-        }
-      });
-      const { drawDetails, derivedInfo } = getDrawDetails({
-        eventEntries,
-        event
-      });
-      Object.assign(derivedDrawInfo, derivedInfo);
-      if (event.eventType === TEAM$1 || // for TEAM events some individual attributes can only be derived by processing
-      params.withScheduleItems || params.scheduleAnalysis || params.withStatistics || params.withOpponents || params.withMatchUps || params.withDraws) {
-        const matchUps = allEventMatchUps({
-          afterRecoveryTimes: params.scheduleAnalysis,
-          participants: allTournamentParticipants,
-          nextMatchUps: true,
-          tournamentRecord,
-          inContext: true,
-          event
-        })?.matchUps;
-        matchUps?.forEach(
-          (matchUp) => processMatchUp({
-            relevantParticipantIdsMap,
-            participantFilters,
-            participantIdMap,
-            derivedDrawInfo,
-            eventDrawsCount,
-            drawDetails,
-            eventType,
-            matchUp
-          })
-        );
-      }
-    });
-  }
-  params.tournamentParticipants?.forEach((participant) => {
-    const { scheduleConflicts, scheduleItems } = annotateParticipant({
-      ...params,
-      eventsPublishStatuses,
-      participantIdMap,
-      derivedDrawInfo,
-      participant
-    });
-    if (params.withSignInStatus) {
-      const { timeItem } = getTimeItem({
-        itemType: SIGN_IN_STATUS,
-        element: participant
-      });
-      participant.signedIn = timeItem?.itemValue === SIGNED_IN;
-    }
-    if (params.withScheduleItems) {
-      participant.scheduleItems = scheduleItems;
-    }
-    if (params.scheduleAnalysis) {
-      participant.scheduleConflicts = scheduleConflicts;
-      if (scheduleConflicts?.length && !participantIdsWithConflicts.includes(participant.participantId)) {
-        participantIdsWithConflicts.push(participant.participantId);
-      }
-    }
-    if (params.withGroupings !== false) {
-      const participantAttributes = participantIdMap[participant.participantId];
-      participant.groupParticipantIds = participantAttributes?.groupParticipantIds;
-      participant.pairParticipantIds = participantAttributes?.pairParticipantIds;
-      participant.teamParticipantIds = participantAttributes?.teamParticipantIds;
-      participant.groups = participantAttributes?.groups;
-      participant.teams = participantAttributes?.teams;
-    }
-    if (params.withTeamMatchUps) ;
-  });
-  return { participantIdsWithConflicts, eventsPublishStatuses };
-}
-
-function getTournamentParticipants(params) {
-  const {
-    participantFilters = {},
-    convertExtensions,
-    policyDefinitions,
-    withScheduleItems,
-    scheduleAnalysis,
-    withSignInStatus,
-    withTeamMatchUps,
-    // not implemented
-    tournamentRecord,
-    usePublishState,
-    withScaleValues,
-    withStatistics,
-    withGroupings,
-    withOpponents,
-    withMatchUps,
-    withSeeding,
-    withEvents,
-    withDraws,
-    inContext,
-    withISO2,
-    withIOC
-  } = params;
-  if (!tournamentRecord)
-    return { error: MISSING_TOURNAMENT_RECORD };
-  if (!tournamentRecord.participants)
-    return { error: MISSING_PARTICIPANTS };
-  const allTournamentParticipants = tournamentRecord.participants.map(
-    // (participant) => makeDeepCopy(participant, convertExtensions, true)
-    (participant) => makeDeepCopy(participant, convertExtensions)
-    // removed until Mongo/Mongoose issues resolved
-  );
-  if (typeof participantFilters !== "object")
-    return { error: INVALID_OBJECT, participantFilters };
-  if (inContext) {
-    allTournamentParticipants?.forEach((participant) => {
-      if ([PAIR, TEAM$2, GROUP].includes(participant.participantType)) {
-        participant.individualParticipants = participant.individualParticipantIds?.map((participantId) => {
-          const targetParticipant = tournamentRecord.participants.find(
-            (p) => p.participantId === participantId
-          );
-          const individualParticipant = makeDeepCopy(
-            targetParticipant,
-            convertExtensions,
-            true
-          );
-          if (withScaleValues) {
-            const { ratings, rankings } = getScaleValues({
-              participant: individualParticipant
-            });
-            individualParticipant.ratings = ratings;
-            individualParticipant.rankings = rankings;
-          }
-          if (withIOC || withISO2)
-            addNationalityCode({
-              participant: individualParticipant,
-              withISO2,
-              withIOC
-            });
-          return individualParticipant;
-        });
-      }
-    });
-  }
-  let tournamentParticipants = participantFilters ? filterParticipants({
-    participants: allTournamentParticipants,
-    participantFilters,
-    tournamentRecord
-  }) : allTournamentParticipants;
-  let participantIdsWithConflicts, eventsPublishStatuses;
-  const addContext = withScheduleItems || withSignInStatus || scheduleAnalysis || withScaleValues || withStatistics || withGroupings || withOpponents || withMatchUps || withSeeding || withEvents || withDraws || withISO2 || withIOC;
-  if (addContext) {
-    const result = addParticipantContext({
-      tournamentEvents: tournamentRecord.events,
-      allTournamentParticipants,
-      tournamentParticipants,
-      participantFilters,
-      withScheduleItems,
-      withSignInStatus,
-      tournamentRecord,
-      scheduleAnalysis,
-      withTeamMatchUps,
-      usePublishState,
-      withScaleValues,
-      withStatistics,
-      withGroupings,
-      withOpponents,
-      withMatchUps,
-      withSeeding,
-      withEvents,
-      withDraws,
-      withISO2,
-      withIOC
-    });
-    participantIdsWithConflicts = result?.participantIdsWithConflicts;
-    eventsPublishStatuses = result?.eventsPublishStatuses;
-  }
-  const participantAttributes = policyDefinitions?.[POLICY_TYPE_PARTICIPANT];
-  if (participantAttributes?.participant) {
-    tournamentParticipants = tournamentParticipants.map(
-      (participant) => attributeFilter({
-        template: participantAttributes.participant,
-        source: participant
-      })
-    );
-  }
-  return {
-    participantIdsWithConflicts,
-    tournamentParticipants,
-    eventsPublishStatuses
-  };
-}
-
 function deepMerge(existing, incoming, arrayMerge) {
   if (!existing && incoming)
     return incoming;
@@ -13871,15 +12891,19 @@ function getCompetitionParticipants(params) {
   let competitionParticipants = [];
   const participantIdsWithConflicts = [];
   const competitionParticipantIds = [];
+  const mappedMatchUps = {};
   for (const tournamentRecord of Object.values(tournamentRecords)) {
     const {
-      tournamentParticipants,
-      participantIdsWithConflicts: idsWithConflicts
-    } = getTournamentParticipants({
+      participants,
+      participantIdsWithConflicts: idsWithConflicts,
+      mappedMatchUps: matchUpsMap
+    } = getParticipants({
       tournamentRecord,
       ...params
     });
-    for (const tournamentParticipant of tournamentParticipants) {
+    if (matchUpsMap)
+      Object.assign(mappedMatchUps, matchUpsMap);
+    for (const tournamentParticipant of participants ?? []) {
       const { participantId } = tournamentParticipant;
       if (!competitionParticipantIds.includes(participantId)) {
         competitionParticipantIds.push(participantId);
@@ -13895,13 +12919,18 @@ function getCompetitionParticipants(params) {
         participantIdsWithConflicts.push(participantId);
     });
   }
-  return { competitionParticipants, participantIdsWithConflicts, ...SUCCESS };
+  return {
+    competitionParticipants,
+    participantIdsWithConflicts,
+    mappedMatchUps,
+    ...SUCCESS
+  };
 }
 function publicFindParticipant({
-  policyDefinitions,
   tournamentRecords,
+  policyDefinitions,
+  contextProfile,
   participantId,
-  inContext,
   personId
 }) {
   if (!tournamentRecords)
@@ -13911,15 +12940,15 @@ function publicFindParticipant({
   let participant, tournamentId;
   for (const tournamentRecord of Object.values(tournamentRecords)) {
     tournamentId = tournamentRecord.tournamentId;
-    const { tournamentParticipants } = getTournamentParticipants({
+    const participants = getParticipants({
       policyDefinitions,
-      tournamentRecord,
-      inContext
-    });
+      tournamentRecord
+    }).participants ?? [];
     participant = findParticipant({
-      tournamentParticipants,
+      tournamentParticipants: participants,
       internalUse: true,
       policyDefinitions,
+      contextProfile,
       participantId,
       personId
     });
@@ -13934,14 +12963,12 @@ function getParticipantScaleItem({
   policyDefinitions,
   scaleAttributes,
   participantId,
-  inContext,
   personId
 }) {
   let result = publicFindParticipant({
     tournamentRecords,
     policyDefinitions,
     participantId,
-    inContext,
     personId
   });
   if (result.error)