tods-competition-factory 1.8.15 → 1.8.17

package/dist/index.mjs

@@ -2382,7 +2382,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.8.15";
+  return "1.8.17";
 }
 
 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];
@@ -4593,8 +4603,8 @@ function findPolicy({
 }
 
 function getMatchUpCompetitiveProfile({
-  profileBands,
   tournamentRecord,
+  profileBands,
   matchUp
 }) {
   if (!matchUp)
@@ -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,
@@ -54607,6 +54617,267 @@ function getEntryStatusReports({
   };
 }
 
+function getParticipantStats({
+  withCompetitiveProfiles,
+  opponentParticipantId,
+  withIndividualStats,
+  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 participantStats = /* @__PURE__ */ new Map();
+  const participantNameMap = /* @__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) {
+      if (side.participant?.participantName)
+        participantNameMap.set(
+          side.participant.participantId,
+          side.participant.participantName
+        );
+    }
+    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 stats = initStats(id, participantNameMap.get(id));
+        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,
@@ -54857,7 +55128,11 @@ function getPositionManipulations({ extensions }) {
   return extensions?.find(({ name }) => name === AUDIT_POSITION_ACTIONS)?.value?.slice(1);
 }
 
-const reportGovernor = { getStructureReports, getEntryStatusReports };
+const reportGovernor = {
+  getStructureReports,
+  getEntryStatusReports,
+  getParticipantStats
+};
 
 function setDrawParticipantRepresentativeIds({
   representativeParticipantIds,