tods-competition-factory 1.8.14 → 1.8.16

package/dist/index.mjs

@@ -2382,7 +2382,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.8.14";
+  return "1.8.16";
 }
 
 function getObjectTieFormat(obj) {
@@ -3189,11 +3189,11 @@ function countSets({
   score
 }) {
   const setsTally = [0, 0];
-  const { sets } = score || {};
-  const matchUpWinnerIndex = matchUpWinningSide - 1;
+  const sets = score?.sets;
+  const matchUpWinnerIndex = typeof matchUpWinningSide === "number" && matchUpWinningSide - 1;
   const parsedMatchUpFormat = parse(matchUpFormat);
   const setsToWin = getSetsToWin(parsedMatchUpFormat?.bestOf ?? 1);
-  if (matchUpStatus === DEFAULTED && tallyPolicy?.setsCreditForDefaults || matchUpStatus === WALKOVER$2 && tallyPolicy?.setsCreditForWalkovers) {
+  if (typeof matchUpWinnerIndex === "number" && (matchUpStatus === DEFAULTED && tallyPolicy?.setsCreditForDefaults || matchUpStatus === WALKOVER$2 && tallyPolicy?.setsCreditForWalkovers)) {
     setsTally[matchUpWinnerIndex] = setsToWin;
   } else {
     for (const set of sets || []) {
@@ -3202,7 +3202,7 @@ function countSets({
         setsTally[setWinningSide - 1] += 1;
     }
   }
-  if (matchUpStatus === RETIRED$1) {
+  if (typeof matchUpWinnerIndex === "number" && matchUpStatus === RETIRED$1) {
     if (+setsTally[1 - matchUpWinnerIndex] === setsToWin)
       setsTally[1 - matchUpWinnerIndex] -= 1;
     if (tallyPolicy?.setsCreditForRetirements)
@@ -3220,13 +3220,13 @@ function countGames({
   const { sets } = score || {};
   if (!sets)
     return [0, 0];
-  const matchUpWinnerIndex = matchUpWinningSide - 1;
+  const matchUpWinnerIndex = typeof matchUpWinningSide === "number" && matchUpWinningSide - 1;
   const parsedMatchUpFormat = parse(matchUpFormat);
   const bestOf = parsedMatchUpFormat?.bestOf ?? 1;
   const setsToWin = getSetsToWin(bestOf);
   const tiebreakAt = parsedMatchUpFormat?.setFormat?.tiebreakAt || 0;
   const gamesTally = [[], []];
-  if (matchUpStatus === DEFAULTED && tallyPolicy?.gamesCreditForDefaults || matchUpStatus === WALKOVER$2 && tallyPolicy?.gamesCreditForWalkovers) {
+  if (typeof matchUpWinnerIndex === "number" && (matchUpStatus === DEFAULTED && tallyPolicy?.gamesCreditForDefaults || matchUpStatus === WALKOVER$2 && tallyPolicy?.gamesCreditForWalkovers)) {
     const gamesForSet = parsedMatchUpFormat?.setFormat?.setTo || 0;
     const minimumGameWins = setsToWin * gamesForSet;
     gamesTally[matchUpWinnerIndex].push(minimumGameWins);
@@ -3246,7 +3246,7 @@ function countGames({
       }
     });
   }
-  if (matchUpStatus === RETIRED$1) {
+  if (matchUpStatus === RETIRED$1 && typeof matchUpWinnerIndex === "number") {
     const whichFormat = sets.length > setsToWin && parsedMatchUpFormat?.finalSetFormat ? "finalSetFormat" : "setFormat";
     const format = parsedMatchUpFormat?.[whichFormat];
     if (isGamesBased(format.based)) {
@@ -3286,10 +3286,14 @@ function countGames({
     gamesTally[1].reduce((a, b) => a + b, 0)
   ];
 }
-function countPoints({ matchUpFormat, score }) {
-  const parsedMatchUpFormat = parse(matchUpFormat);
+function countPoints({
+  matchUpFormat,
+  score
+}) {
+  const parsedMatchUpFormat = matchUpFormat ? parse(matchUpFormat) : void 0;
   const bestOf = parsedMatchUpFormat?.bestOf ?? 1;
   const setsToWin = getSetsToWin(bestOf);
+  const tiebreaksTally = [0, 0];
   const pointsTally = [0, 0];
   score?.sets?.forEach((set, i) => {
     const setNumber = set.setNumber || i + 1;
@@ -3306,9 +3310,11 @@ function countPoints({ matchUpFormat, score }) {
         pointsTally[0] += ensureInt(set.side1TiebreakScore || 0);
       if (set.side2TiebreakScore)
         pointsTally[1] += ensureInt(set.side2TiebreakScore || 0);
+      if ((set.side1TiebreakScore || set.side2TiebreakScore) && set.winningSide)
+        tiebreaksTally[set.winningSide - 1] += 1;
     }
   });
-  return pointsTally;
+  return { pointsTally, tiebreaksTally };
 }
 function getSetsToWin(bestOfGames) {
   return bestOfGames && Math.ceil(bestOfGames / 2) || 1;
@@ -3423,7 +3429,7 @@ function getParticipantResults({
     const winningParticipantId = winningSide && getWinningSideId(matchUp);
     const losingParticipantId = winningSide && getLosingSideId(matchUp);
     if (!winningParticipantId && !losingParticipantId) {
-      if (completedMatchUpStatuses.includes(matchUpStatus)) {
+      if (matchUpStatus && completedMatchUpStatuses.includes(matchUpStatus)) {
         const participantIdSide1 = getSideId(matchUp, 0);
         const participantIdSide2 = getSideId(matchUp, 1);
         if (participantIdSide1) {
@@ -3438,10 +3444,10 @@ function getParticipantResults({
         perPlayer = 0;
         for (const tieMatchUp of tieMatchUps) {
           if (tieMatchUp.winningSide) {
-            const tieWinningParticipantId = sides.find(
+            const tieWinningParticipantId = sides?.find(
               ({ sideNumber }) => sideNumber === tieMatchUp.winningSide
             )?.participantId;
-            const tieLosingParticipantId = sides.find(
+            const tieLosingParticipantId = sides?.find(
               ({ sideNumber }) => sideNumber === tieMatchUp.winningSide
             )?.participantId;
             if (tieWinningParticipantId && tieLosingParticipantId) {
@@ -3560,26 +3566,30 @@ function getParticipantResults({
       }
     }
     if (manualGamesOverride) {
-      const side1participantId = sides.find(
+      const side1participantId = sides?.find(
         ({ sideNumber }) => sideNumber === 1
       )?.participantId;
-      const side2participantId = sides.find(
+      const side2participantId = sides?.find(
         ({ sideNumber }) => sideNumber === 2
       )?.participantId;
       checkInitializeParticipant(participantResults, side1participantId);
       checkInitializeParticipant(participantResults, side2participantId);
-      const gamesWonSide1 = score.sets.reduce(
-        (total, set) => total + set.side1Score,
+      const gamesWonSide1 = score?.sets?.reduce(
+        (total, set) => total + (set?.side1Score ?? 0),
         0
       );
-      const gamesWonSide2 = score.sets.reduce(
-        (total, set) => total + set.side2Score,
+      const gamesWonSide2 = score?.sets?.reduce(
+        (total, set) => total + (set.side2Score ?? 0),
         0
       );
-      participantResults[side1participantId].gamesWon += gamesWonSide1;
-      participantResults[side2participantId].gamesWon += gamesWonSide2;
-      participantResults[side1participantId].gamesLost += gamesWonSide2;
-      participantResults[side2participantId].gamesLost += gamesWonSide1;
+      if (side1participantId) {
+        participantResults[side1participantId].gamesWon += gamesWonSide1;
+        participantResults[side1participantId].gamesLost += gamesWonSide2;
+      }
+      if (side2participantId) {
+        participantResults[side2participantId].gamesWon += gamesWonSide2;
+        participantResults[side2participantId].gamesLost += gamesWonSide1;
+      }
     }
   }
   calculatePercentages({
@@ -3706,7 +3716,7 @@ function processMatchUp$1({
     winningSide,
     score
   });
-  const pointsTally = countPoints({ score, matchUpFormat });
+  const { pointsTally } = countPoints({ score, matchUpFormat });
   if (winningParticipantId) {
     participantResults[winningParticipantId].setsWon += setsTally[winningSideIndex];
     participantResults[winningParticipantId].setsLost += setsTally[losingSideIndex];
@@ -15597,6 +15607,21 @@ function addNationalityCode({
   persons.forEach(annotatePerson);
 }
 
+function addIndividualParticipants({ participantMap }) {
+  const participantObjects = Object.values(participantMap);
+  for (const participantObject of participantObjects) {
+    const participant = participantObject.participant;
+    if (participant.individualParticipantIds?.length) {
+      participant.individualParticipants = [];
+      for (const participantId of participant.individualParticipantIds) {
+        participant.individualParticipants.push(
+          participantMap[participantId].participant
+        );
+      }
+    }
+  }
+}
+
 function getTimeItem({
   returnPreviousValues,
   itemSubTypes,
@@ -15778,20 +15803,6 @@ function signedIn(participant) {
   });
   return timeItem?.itemValue === SIGNED_IN;
 }
-function addIndividualParticipants({ participantMap }) {
-  const participantObjects = Object.values(participantMap);
-  for (const participantObject of participantObjects) {
-    const participant = participantObject.participant;
-    if (participant.individualParticipantIds?.length) {
-      participant.individualParticipants = [];
-      for (const participantId of participant.individualParticipantIds) {
-        participant.individualParticipants.push(
-          participantMap[participantId].participant
-        );
-      }
-    }
-  }
-}
 function processIndividualParticipantIds({
   individualParticipantIds,
   participantCopy,
@@ -16070,7 +16081,6 @@ function allEventMatchUps(params) {
   if (!event)
     return { error: MISSING_EVENT };
   const { eventId, eventName, endDate, category, gender, matchUpFormat } = event;
-  const eventMatchUps2 = [];
   const additionalContext = {
     ...context,
     ...definedAttributes({
@@ -16114,7 +16124,7 @@ function allEventMatchUps(params) {
   }).scheduleTiming;
   const matchUps = drawDefinitions.flatMap(
     (drawDefinition) => {
-      const { matchUps: matchUps2, matchUpsMap } = getAllDrawMatchUps({
+      const { matchUps: matchUps2 } = getAllDrawMatchUps({
         tournamentParticipants: participants,
         tournamentAppliedPolicies,
         scheduleVisibilityFilters,
@@ -16134,12 +16144,10 @@ function allEventMatchUps(params) {
         inContext,
         event
       });
-      if (matchUpsMap?.drawMatchUps)
-        eventMatchUps2.push(...matchUpsMap.drawMatchUps);
       return matchUps2 ?? [];
     }
   );
-  return { matchUps, eventMatchUps: eventMatchUps2 };
+  return { matchUps };
 }
 function tournamentMatchUps(params) {
   if (!params?.tournamentRecord)
@@ -27850,7 +27858,6 @@ function getParticipants$1(params) {
     getMatchUpDependencies({ tournamentRecord });
   }
   let { participantMap } = getParticipantMap({
-    withIndividualParticipants,
     convertExtensions,
     tournamentRecord,
     withSignInStatus,
@@ -27889,45 +27896,48 @@ function getParticipants$1(params) {
   const matchUps = entriesResult.matchUps;
   participantMap = entriesResult.participantMap;
   const nextMatchUps = scheduleAnalysis ?? withPotentialMatchUps;
-  const processedParticipants = Object.values(participantMap).map(
-    ({
-      potentialMatchUps,
-      scheduleConflicts,
-      scheduleItems,
-      participant,
-      statistics,
-      opponents,
-      matchUps: matchUps2,
-      events,
-      draws
-    }) => {
-      const participantDraws = Object.values(draws);
-      const participantOpponents = Object.values(opponents);
-      if (withOpponents) {
-        participantDraws?.forEach((draw) => {
-          draw.opponents = participantOpponents.filter(
-            (opponent) => opponent.drawId === draw.drawId
-          );
-        });
-      }
-      return definedAttributes(
-        {
-          ...participant,
-          scheduleConflicts: scheduleAnalysis ? scheduleConflicts : void 0,
-          draws: withDraws || withRankingProfile ? participantDraws : void 0,
-          events: withEvents || withRankingProfile ? Object.values(events) : void 0,
-          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,
-          scheduleItems: withScheduleItems ? scheduleItems : void 0
-        },
-        false,
-        false,
-        true
-      );
+  const processParticipant = ({
+    potentialMatchUps,
+    scheduleConflicts,
+    scheduleItems,
+    participant,
+    statistics,
+    opponents,
+    matchUps: matchUps2,
+    events,
+    draws
+  }) => {
+    const participantDraws = Object.values(draws);
+    const participantOpponents = Object.values(opponents);
+    if (withOpponents) {
+      participantDraws?.forEach((draw) => {
+        draw.opponents = participantOpponents.filter(
+          (opponent) => opponent.drawId === draw.drawId
+        );
+      });
     }
-  );
+    return definedAttributes(
+      {
+        ...participant,
+        scheduleConflicts: scheduleAnalysis ? scheduleConflicts : void 0,
+        draws: withDraws || withRankingProfile ? participantDraws : void 0,
+        events: withEvents || withRankingProfile ? Object.values(events) : void 0,
+        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,
+        scheduleItems: withScheduleItems ? scheduleItems : void 0
+      },
+      false,
+      false,
+      true
+    );
+  };
+  const ppMap = /* @__PURE__ */ new Map();
+  for (const participantId of Object.keys(participantMap)) {
+    ppMap.set(participantId, processParticipant(participantMap[participantId]));
+  }
+  const processedParticipants = [...ppMap.values()];
   const participantAttributes = policyDefinitions?.[POLICY_TYPE_PARTICIPANT];
   const template = participantAttributes?.participant;
   const filteredParticipants = filterParticipants({
@@ -27935,6 +27945,17 @@ function getParticipants$1(params) {
     participantFilters,
     tournamentRecord
   });
+  if (withIndividualParticipants) {
+    for (const participant of filteredParticipants) {
+      for (const individualParticipantId of participant.individualParticipantIds ?? []) {
+        if (!participant.individualParticipants)
+          participant.individualParticipants = [];
+        participant.individualParticipants.push(
+          ppMap.get(individualParticipantId)
+        );
+      }
+    }
+  }
   const participants = template ? filteredParticipants.map(
     (source) => attributeFilter({ source, template })
   ) : filteredParticipants;
@@ -37975,7 +37996,7 @@ function setState$4(records, deepCopyOption = true) {
 function engineLogging({ result, methodName, elapsed, params, engine }) {
   const devContext = getDevContext();
   const log = { method: methodName };
-  const logError = result.error && (devContext.errors === true || Array.isArray(devContext.errors) && devContext.errors.includes(methodName));
+  const logError = result?.error && (devContext.errors === true || Array.isArray(devContext.errors) && devContext.errors.includes(methodName));
   const specifiedMethodParams = Array.isArray(devContext.params) && devContext.params?.includes(methodName);
   const logParams = devContext.params && !Array.isArray(devContext.params) || specifiedMethodParams;
   const exclude = Array.isArray(devContext.exclude) && devContext.exclude.includes(methodName);
@@ -37989,7 +38010,7 @@ function engineLogging({ result, methodName, elapsed, params, engine }) {
   }
   if (Object.keys(log).length > 1)
     console.log(engine, log);
-  if (devContext.makeDeepCopy)
+  if (result && devContext.makeDeepCopy)
     result.deepCopyIterations = getDeepCopyIterations();
 }
 
@@ -43525,7 +43546,7 @@ function buildDrawHierarchy({
   const firstRoundDrawPositions = firstRoundPairedDrawPositions.flat(Infinity);
   const secondRoundDrawPositions = secondRoundMatchUps.map((matchUp) => matchUp.drawPositions).flat(Infinity);
   const secondRoundEntries = secondRoundDrawPositions.filter((drawPosition) => !firstRoundDrawPositions.includes(drawPosition)).sort(drawPositionSort);
-  const secondRoundEntriySides = secondRoundMatchUps.filter(
+  const secondRoundEntrySides = secondRoundMatchUps.filter(
     (matchUp) => matchUp.drawPositions?.reduce(
       (p, c) => secondRoundEntries.includes(c) || p,
       void 0
@@ -43543,7 +43564,7 @@ function buildDrawHierarchy({
     const missingPairs = secondRoundEntries.map((drawPosition, index) => {
       return [drawPosition, missingDrawPositions[index]].sort(drawPositionSort);
     });
-    const entrySides = Object.assign({}, ...secondRoundEntriySides);
+    const entrySides = Object.assign({}, ...secondRoundEntrySides);
     const finishingRound = makeDeepCopy(
       firstRoundMatchUps?.[0].finishingRound,
       false,
@@ -54846,7 +54867,197 @@ function getPositionManipulations({ extensions }) {
   return extensions?.find(({ name }) => name === AUDIT_POSITION_ACTIONS)?.value?.slice(1);
 }
 
-const reportGovernor = { getStructureReports, getEntryStatusReports };
+function getTeamStats({
+  opponentParticipantId,
+  teamParticipantId,
+  tournamentRecord,
+  tallyPolicy,
+  matchUps
+}) {
+  if (!tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  if (matchUps && !Array.isArray(matchUps))
+    return { error: INVALID_MATCHUP };
+  matchUps = matchUps || allTournamentMatchUps({ tournamentRecord }).matchUps;
+  if (!matchUps?.length)
+    return { error: MISSING_MATCHUPS };
+  const teamParticipantIds = [];
+  if (opponentParticipantId)
+    teamParticipantIds.push(opponentParticipantId);
+  if (teamParticipantId)
+    teamParticipantIds.push(teamParticipantId);
+  const participantFilters = !teamParticipantIds.length ? { participantTypes: [TEAM_PARTICIPANT] } : { participantIds: teamParticipantIds };
+  const teamParticipants = getParticipants$1({ participantFilters, tournamentRecord }).participants ?? [];
+  if (!teamParticipants.every(
+    ({ participantType }) => participantType === TEAM_PARTICIPANT
+  )) {
+    return { error: INVALID_PARTICIPANT_IDS };
+  }
+  if (!teamParticipantIds.length)
+    teamParticipantIds.push(...teamParticipants.map(extractAttributes("participantId")));
+  const teamStats = /* @__PURE__ */ new Map();
+  const teamMap = /* @__PURE__ */ new Map();
+  for (const teamParticipant of teamParticipants) {
+    const { participantId, individualParticipantIds } = teamParticipant;
+    teamMap.set(participantId, individualParticipantIds ?? []);
+    teamStats.set(participantId, {
+      participantName: teamParticipant.participantName ?? "",
+      matchUpStatuses: {},
+      competitorIds: [],
+      tiebreaks: [0, 0],
+      matchUps: [0, 0],
+      points: [0, 0],
+      participantId,
+      games: [0, 0],
+      sets: [0, 0]
+    });
+  }
+  if (teamParticipantId && !teamMap.get(teamParticipantId))
+    return decorateResult({
+      result: { error: PARTICIPANT_NOT_FOUND },
+      context: { teamParticipantId }
+    });
+  if (opponentParticipantId && !teamMap.get(opponentParticipantId))
+    return decorateResult({
+      result: { error: PARTICIPANT_NOT_FOUND },
+      context: { opponentParticipantId }
+    });
+  const relevantMatchUps = [];
+  const getTeamParticipantIds = (sides) => {
+    const sideTeamParticipantIds = [];
+    const isTeamSide = (side, individualParticipantIds) => {
+      return !!(side.participantId && individualParticipantIds.includes(side.participantId) || side.participant?.individualParticipantIds?.length && intersection(
+        individualParticipantIds,
+        side.participant?.individualParticipantIds
+      ).length === side.participant?.individualParticipantIds?.length);
+    };
+    for (const [teamParticipantId2, individualParticipantIds] of teamMap) {
+      for (const side of sides) {
+        if (!side.participant)
+          continue;
+        if (isTeamSide(side, individualParticipantIds)) {
+          const sideNumber = side.sideNumber;
+          if (!sideNumber)
+            continue;
+          sideTeamParticipantIds[sideNumber - 1] = teamParticipantId2;
+          const competitorIds = side.participant?.individualParticipantIds?.length ? side.participant.individualParticipantIds : [side.participant.participantId];
+          const stats = teamStats.get(teamParticipantId2);
+          for (const id of competitorIds) {
+            if (stats && !stats.competitorIds.includes(id))
+              stats.competitorIds.push(id);
+          }
+        }
+      }
+    }
+    return sideTeamParticipantIds;
+  };
+  for (const matchUp of matchUps) {
+    if (!isObject(matchUp))
+      return { error: INVALID_MATCHUP };
+    const {
+      matchUpStatus,
+      matchUpFormat,
+      matchUpType,
+      winningSide,
+      score,
+      sides
+    } = matchUp;
+    if (!sides || !score || matchUpType === TEAM_MATCHUP || matchUpStatus === BYE)
+      continue;
+    const teamParticipantIds2 = getTeamParticipantIds(sides);
+    if (!teamParticipantIds2.filter(Boolean).length)
+      continue;
+    relevantMatchUps.push(matchUp);
+    const setsTally = countSets({
+      matchUpStatus,
+      matchUpFormat,
+      tallyPolicy,
+      winningSide,
+      score
+    });
+    const gamesTally = countGames({
+      matchUpStatus,
+      matchUpFormat,
+      tallyPolicy,
+      winningSide,
+      score
+    });
+    const { pointsTally, tiebreaksTally } = countPoints({
+      matchUpFormat,
+      score
+    });
+    teamParticipantIds2.forEach((teamParticipantId2, index) => {
+      if (teamParticipantId2) {
+        const stats = teamStats.get(teamParticipantId2);
+        if (stats) {
+          const teamSumTally = (stat, tally) => tally.forEach((t, i) => stats[stat][i] += t);
+          const tiebreaks = index ? [...tiebreaksTally].reverse() : tiebreaksTally;
+          const points = index ? [...pointsTally].reverse() : pointsTally;
+          const games = index ? [...gamesTally].reverse() : gamesTally;
+          const sets = index ? [...setsTally].reverse() : setsTally;
+          teamSumTally("tiebreaks", tiebreaks);
+          teamSumTally("points", points);
+          teamSumTally("games", games);
+          teamSumTally("sets", sets);
+          if (winningSide) {
+            const tallyIndex = winningSide - 1 === index ? 0 : 1;
+            stats.matchUps[tallyIndex] += 1;
+          }
+          if (matchUpStatus) {
+            if (!stats.matchUpStatuses[matchUpStatus])
+              stats.matchUpStatuses[matchUpStatus] = 0;
+            stats.matchUpStatuses[matchUpStatus] += 1;
+          }
+        }
+      }
+    });
+  }
+  const attrs = ["tiebreaks", "matchUps", "points", "games", "sets"];
+  const ratio = /* @__PURE__ */ new Map();
+  const add = (a, b) => (a ?? 0) + (b ?? 0);
+  for (const stats of teamStats.values()) {
+    for (const attr of attrs) {
+      const total = stats[attr].reduce(add);
+      if (total) {
+        const value = stats[attr][0] / total;
+        const accessor = `${attr}Ratio`;
+        const fixedValue = parseFloat(value.toFixed(2));
+        stats[accessor] = fixedValue;
+        if (!ratio.has(accessor))
+          ratio.set(accessor, []);
+        ratio.get(accessor)?.push(fixedValue);
+      }
+    }
+  }
+  const highLowSort = (a, b) => b - a;
+  for (const stats of teamStats.values()) {
+    for (const attr of attrs) {
+      const accessor = `${attr}Ratio`;
+      if (typeof stats[accessor] === "number") {
+        const index = ratio.get(accessor)?.sort(highLowSort).indexOf(stats[accessor]);
+        if (typeof index === "number" && index >= 0) {
+          const rankAccessor = `${attr}Rank`;
+          stats[rankAccessor] = index + 1;
+        }
+      }
+    }
+  }
+  const result = { relevantMatchUps, ...SUCCESS };
+  if (teamParticipantId) {
+    result.teamStats = teamStats.get(teamParticipantId);
+    if (opponentParticipantId)
+      result.opponentStats = teamStats.get(opponentParticipantId);
+  } else {
+    result.allTeamStats = [...teamStats.values()];
+  }
+  return result;
+}
+
+const reportGovernor = {
+  getStructureReports,
+  getEntryStatusReports,
+  getTeamStats
+};
 
 function setDrawParticipantRepresentativeIds({
   representativeParticipantIds,
@@ -59090,7 +59301,7 @@ function aggregateTieFormats({
       }
     }
     const setTieFormatId = (matchUpId, tieFormatId) => {
-      const matchUp = eventMatchUpResult.eventMatchUps?.find(
+      const matchUp = eventMatchUpResult.matchUps?.find(
         (matchUp2) => matchUp2.matchUpId === matchUpId
       );
       if (matchUp) {
@@ -59368,6 +59579,7 @@ function getMaxEntryPosition(params) {
 function getPredictiveAccuracy(params) {
   let { matchUps } = params;
   const {
+    singlesForDoubles,
     tournamentRecord,
     drawDefinition,
     excludeMargin,
@@ -59442,6 +59654,7 @@ function getPredictiveAccuracy(params) {
   const marginCalc = !zoneDoubling || matchUpType === SINGLES$1 ? zoneMargin : (zoneMargin || 0) * 2;
   const zoneData = zoneMargin ? relevantMatchUps.map(({ competitiveProfile, matchUpType: matchUpType2, score, sides }) => {
     const sideValues = getSideValues({
+      singlesForDoubles,
       valueAccessor,
       matchUpType: matchUpType2,
       scaleName,
@@ -59485,6 +59698,7 @@ function getGroupingBands({ zoneData }) {
   return bands;
 }
 function getSideValues({
+  singlesForDoubles,
   exclusionRule,
   valueAccessor,
   matchUpType,
@@ -59505,6 +59719,7 @@ function getSideValues({
       let value = 0;
       for (const participant2 of individualParticipants) {
         const { scaleValue, value: pValue } = getSideValue({
+          singlesForDoubles,
           valueAccessor,
           participant: participant2,
           matchUpType,
@@ -59528,6 +59743,7 @@ function getSideValues({
       };
     } else if (participant) {
       const { scaleValue, value } = getSideValue({
+        singlesForDoubles,
         valueAccessor,
         matchUpType,
         participant,
@@ -59547,11 +59763,18 @@ function getSideValues({
     }
   });
 }
-function getSideValue({ participant, valueAccessor, matchUpType, scaleName }) {
-  const ranking = participant?.rankings?.[matchUpType]?.find(
+function getSideValue({
+  singlesForDoubles,
+  valueAccessor,
+  matchUpType,
+  participant,
+  scaleName
+}) {
+  const type = singlesForDoubles ? SINGLES$1 : matchUpType;
+  const ranking = participant?.rankings?.[type]?.find(
     (ranking2) => ranking2.scaleName === scaleName
   );
-  const rating = participant?.ratings?.[matchUpType]?.find(
+  const rating = participant?.ratings?.[type]?.find(
     (rating2) => rating2.scaleName === scaleName
   );
   const scaleValue = (rating || ranking)?.scaleValue;
@@ -59832,11 +60055,15 @@ function getEvents({
       }
       const ratings = eventsMap[eventId].ratings;
       for (const scaleName of Object.keys(ratings)) {
+        const scaleRating = ratings[scaleName];
+        if (!scaleRating.length)
+          continue;
+        const med = median(scaleRating)?.toFixed(2);
         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])
+          avg: parseFloat((sum(scaleRating) / scaleRating.length).toFixed(2)),
+          median: med ? parseFloat(med) : void 0,
+          max: Math.max(...scaleRating),
+          min: Math.min(...scaleRating)
         };
       }
       const processFlight = (drawId, participantIds2) => {
@@ -59899,11 +60126,15 @@ function getEvents({
       for (const drawId of processedDrawIds) {
         const ratings2 = eventsMap[eventId].draws[drawId].ratings;
         for (const scaleName of Object.keys(ratings2)) {
+          const scaleRating = ratings2[scaleName];
+          if (!scaleRating.length)
+            continue;
+          const med = median(scaleRating)?.toFixed(2);
           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])
+            avg: parseFloat((sum(scaleRating) / scaleRating.length).toFixed(2)),
+            median: med ? parseFloat(med) : void 0,
+            max: Math.max(...scaleRating),
+            min: Math.min(...scaleRating)
           };
         }
       }