tods-competition-factory 1.8.16 → 1.8.18

package/dist/index.mjs

@@ -2382,7 +2382,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.8.16";
+  return "1.8.18";
 }
 
 function getObjectTieFormat(obj) {
@@ -4603,8 +4603,8 @@ function findPolicy({
 }
 
 function getMatchUpCompetitiveProfile({
-  profileBands,
   tournamentRecord,
+  profileBands,
   matchUp
 }) {
   if (!matchUp)
@@ -15940,8 +15940,8 @@ function allTournamentMatchUps(params) {
   if (!participants) {
     ({ participants, participantMap } = hydrateParticipants({
       participantsProfile,
-      policyDefinitions,
       useParticipantMap,
+      policyDefinitions,
       tournamentRecord,
       contextProfile,
       inContext
@@ -54617,6 +54617,272 @@ function getEntryStatusReports({
   };
 }
 
+function getParticipantStats({
+  withCompetitiveProfiles,
+  opponentParticipantId,
+  withIndividualStats,
+  teamParticipantId,
+  tournamentRecord,
+  withScaleValues,
+  tallyPolicy,
+  matchUps
+}) {
+  if (!tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  if (matchUps && !Array.isArray(matchUps))
+    return { error: INVALID_MATCHUP };
+  const participantsProfile = withScaleValues ? { withScaleValues } : void 0;
+  matchUps = matchUps || allTournamentMatchUps({ tournamentRecord, participantsProfile }).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 participantDetails = /* @__PURE__ */ new Map();
+  const participantStats = /* @__PURE__ */ new Map();
+  const participating = /* @__PURE__ */ new Map();
+  const teamMap = /* @__PURE__ */ new Map();
+  const initStats = (participantId, participantName = "") => participantStats.get(participantId) || participantStats.set(participantId, {
+    participantName,
+    participantId,
+    competitorIds: [],
+    competitiveness: {},
+    matchUpStatuses: {},
+    tiebreaks: [0, 0],
+    matchUps: [0, 0],
+    points: [0, 0],
+    games: [0, 0],
+    sets: [0, 0]
+  }) && participantStats.get(participantId);
+  for (const teamParticipant of teamParticipants) {
+    const { participantId, individualParticipantIds } = teamParticipant;
+    teamMap.set(participantId, individualParticipantIds ?? []);
+    initStats(participantId, teamParticipant.participantName);
+  }
+  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 getSideParticipantIds = (sides) => {
+    const sideParticipantIds = [[], []];
+    for (const side of sides) {
+      const participant = side.participant;
+      if (participant?.participantName) {
+        participantDetails.set(participant.participantId, {
+          participantName: participant.participantName,
+          ratings: participant.ratings
+        });
+      }
+    }
+    const getCompetitorIds = ({ side, individualParticipantIds }) => {
+      return side.participantId && (!individualParticipantIds?.length || individualParticipantIds.includes(side.participantId)) && [
+        side.participantId
+      ] || side.participant?.individualParticipantIds?.length && (!individualParticipantIds?.length || intersection(
+        individualParticipantIds,
+        side.participant?.individualParticipantIds
+      ).length === side.participant?.individualParticipantIds?.length) && side.participant.individualParticipantIds;
+    };
+    if (teamMap.size) {
+      const processSides = (thisTeamId, individualParticipantIds) => {
+        for (const side of sides) {
+          if (!side.participant)
+            continue;
+          const competitorIds = getCompetitorIds({
+            individualParticipantIds,
+            side
+          });
+          if (competitorIds?.length) {
+            const sideNumber = side.sideNumber;
+            if (!sideNumber)
+              continue;
+            const ids = [thisTeamId];
+            if (withIndividualStats)
+              ids.push(...competitorIds);
+            sideParticipantIds[sideNumber - 1] = ids;
+            const stats = participantStats.get(thisTeamId);
+            for (const id of competitorIds.filter(Boolean)) {
+              if (stats && !stats.competitorIds.includes(id))
+                stats.competitorIds.push(id);
+            }
+          }
+        }
+      };
+      if (teamParticipantId) {
+        const processForTeam = !opponentParticipantId || sides.every((side) => {
+          side.participant && (getCompetitorIds({
+            side,
+            individualParticipantIds: teamMap.get(teamParticipantId)
+          }) || getCompetitorIds({
+            side,
+            individualParticipantIds: teamMap.get(opponentParticipantId)
+          }));
+        });
+        if (processForTeam)
+          processSides(teamParticipantId, teamMap.get(teamParticipantId));
+      } else {
+        for (const [thisTeamId, individualParticipantIds] of teamMap) {
+          processSides(thisTeamId, individualParticipantIds);
+        }
+      }
+    } else if (withIndividualStats) {
+      for (const side of sides) {
+        if (!side.participant)
+          continue;
+        const competitorIds = getCompetitorIds({
+          individualParticipantIds: [],
+          side
+        });
+        const sideNumber = side.sideNumber;
+        if (!sideNumber)
+          continue;
+        sideParticipantIds[sideNumber - 1] = competitorIds;
+      }
+    }
+    return sideParticipantIds;
+  };
+  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 sideParticipantIds = getSideParticipantIds(sides);
+    if (!sideParticipantIds.filter(Boolean).length)
+      continue;
+    const competitiveness = withCompetitiveProfiles && winningSide && getMatchUpCompetitiveProfile({ matchUp })?.competitiveness;
+    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
+    });
+    sideParticipantIds.forEach((ids, index) => {
+      for (const id of ids) {
+        const participantName = participantDetails.get(id)?.participantName;
+        const stats = initStats(id, participantName);
+        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 (competitiveness) {
+            const attr = competitiveness.toLowerCase();
+            if (!stats.competitiveness[attr])
+              stats.competitiveness[attr] = [0, 0];
+            stats.competitiveness[attr][index] += 1;
+          }
+          if (matchUpStatus) {
+            const attr = matchUpStatus.toLowerCase();
+            if (!stats.matchUpStatuses[attr])
+              stats.matchUpStatuses[attr] = 0;
+            stats.matchUpStatuses[attr] += 1;
+          }
+        }
+      }
+    });
+  }
+  const statsattributes = ["tiebreaks", "matchUps", "points", "games", "sets"];
+  const competitivenessAttributes = ["competitive", "routine", "decisive"];
+  const ratio = /* @__PURE__ */ new Map();
+  const add = (a, b) => (a ?? 0) + (b ?? 0);
+  for (const [participantId, stats] of participantStats.entries()) {
+    for (const attr of statsattributes) {
+      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;
+        participating.set(participantId, true);
+        if (!ratio.has(accessor))
+          ratio.set(accessor, []);
+        ratio.get(accessor)?.push(fixedValue);
+      }
+    }
+    for (const attr of competitivenessAttributes) {
+      const total = stats.competitiveness?.[attr]?.reduce(add);
+      if (total) {
+        const value = stats.competitiveness[attr][0] / total;
+        const accessor = `${attr}Ratio`;
+        const fixedValue = parseFloat(value.toFixed(2));
+        stats[accessor] = fixedValue;
+      }
+    }
+  }
+  if (!teamParticipantId) {
+    const highLowSort = (a, b) => b - a;
+    for (const stats of participantStats.values()) {
+      for (const attr of statsattributes) {
+        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 = participantStats.get(teamParticipantId);
+    if (opponentParticipantId)
+      result.opponentStats = participantStats.get(opponentParticipantId);
+  } else {
+    result.participatingTeamsCount = participating.size;
+  }
+  result.allParticipantStats = [...participantStats.values()];
+  return result;
+}
+
 function getAvgWTN({
   eventType,
   matchUps,
@@ -54867,196 +55133,10 @@ function getPositionManipulations({ extensions }) {
   return extensions?.find(({ name }) => name === AUDIT_POSITION_ACTIONS)?.value?.slice(1);
 }
 
-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
+  getParticipantStats
 };
 
 function setDrawParticipantRepresentativeIds({
@@ -60068,10 +60148,10 @@ function getEvents({
       }
       const processFlight = (drawId, participantIds2) => {
         const processParticipant2 = (participant) => {
-          if (participant?.ratings?.[eventType]) {
+          if (eventsMap[eventId].draws?.[drawId] && participant?.ratings?.[eventType]) {
             for (const rating of participant?.ratings?.[eventType] ?? []) {
               const scaleName = rating.scaleName;
-              if (!eventsMap[eventId].draws[drawId].ratings[scaleName])
+              if (!eventsMap[eventId].draws[drawId]?.ratings[scaleName])
                 eventsMap[eventId].draws[drawId].ratings[scaleName] = [];
               const accessor = ratingsParameters[scaleName]?.accessor;
               if (accessor) {