tods-competition-factory 1.8.15 → 1.8.16

package/dist/index.mjs

@@ -2382,7 +2382,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.8.15";
+  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];
@@ -37986,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);
@@ -38000,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();
 }
 
@@ -43536,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
@@ -43554,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,
@@ -54857,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,