tods-competition-factory 1.2.26 → 1.2.28

package/dist/forge/generate.mjs

@@ -16019,6 +16019,60 @@ function processOutcome({
   }
 }
 
+function getTallyReport({ matchUps, order, report }) {
+  const participants = {};
+  matchUps.forEach(({ sides }) => {
+    sides.forEach((side) => {
+      if (side.participantId && side.participant) {
+        participants[side.participantId] = side.participant.participantName;
+      }
+    });
+  });
+  const readable = [];
+  if (Array.isArray(report)) {
+    report.forEach((step, i) => {
+      var _a;
+      if ((_a = step.excludedDirectives) == null ? void 0 : _a.length) {
+        const attributes = step.excludedDirectives.map(({ attribute }) => attribute).join(", ");
+        const note = `${attributes.length} directives were excluded due to participants limit}`;
+        readable.push(note);
+        const excluded = `Excluded: ${attributes}`;
+        readable.push(excluded);
+      } else {
+        const floatSort = (a, b) => parseFloat(step.reversed ? a : b) - parseFloat(step.reversed ? b : a);
+        const getExplanation = (step2) => {
+          Object.keys(step2.groups).sort(floatSort).forEach((key) => {
+            const participantNames = step2.groups[key].map((participantId) => participants[participantId]).join(", ");
+            const explanation = `${key} ${step2.attribute}: ${participantNames}`;
+            readable.push(explanation);
+          });
+        };
+        const reversed = step.reversed ? " in reverse order" : "";
+        const participantsCount = Object.values(step.groups).flat(
+          Infinity
+        ).length;
+        const description = `Step ${i + 1}: ${participantsCount} particiants were grouped${reversed} by ${step.attribute}`;
+        readable.push(description);
+        if (step.idsFilter) {
+          const note = `${step.attribute} was calculated considering ONLY TIED PARTICIPANTS`;
+          readable.push(note);
+        }
+        getExplanation(step);
+      }
+      readable.push("----------------------");
+    });
+  }
+  readable.push("Final Order:");
+  order.forEach((orderEntry) => {
+    const { participantId, resolved } = orderEntry;
+    const pOrder = orderEntry.groupOrder || orderEntry.provisionalOrder;
+    readable.push(
+      `${pOrder}: ${participants[participantId]} => resolved: ${resolved}`
+    );
+  });
+  return readable.join("\r\n");
+}
+
 var __defProp$C = Object.defineProperty;
 var __getOwnPropSymbols$C = Object.getOwnPropertySymbols;
 var __hasOwnProp$C = Object.prototype.hasOwnProperty;
@@ -16063,8 +16117,9 @@ function getGroupOrder(params) {
     subOrderMap,
     tallyPolicy
   } = params;
+  const report = [];
   if (requireCompletion && !isComplete(params))
-    return;
+    return {};
   const attribute = [
     "tieMatchUpsWon",
     "tieSinglesWon",
@@ -16082,7 +16137,12 @@ function getGroupOrder(params) {
     participantResults,
     attribute
   });
-  const groupOrder = Object.keys(orderedTallyGroups).map((key) => parseFloat(key)).sort((a, b) => b - a).map((key) => orderedTallyGroups[key]).map((participantIds) => groupSubSort(__spreadValues$C({ participantIds }, params))).flat(Infinity);
+  report.push({ attribute, groups: orderedTallyGroups });
+  const groupOrder = Object.keys(orderedTallyGroups).map((key) => parseFloat(key)).sort((a, b) => b - a).map((key) => orderedTallyGroups[key]).map((participantIds) => {
+    const result = groupSubSort(__spreadValues$C({ participantIds }, params));
+    report.push(result.report);
+    return result.order;
+  }).flat(Infinity);
   let groupPosition = 1;
   let priorPositionResolution;
   groupOrder.forEach((finishingPosition, index) => {
@@ -16120,7 +16180,7 @@ function getGroupOrder(params) {
       finishingPosition.groupOrder = position + (finishingPosition.subOrder || 1) - 1;
     }
   });
-  return groupOrder;
+  return { groupOrder, report: report.flat(Infinity).filter(Boolean) };
   function getRatioHash(result) {
     const attributes = Array.isArray(tallyPolicy == null ? void 0 : tallyPolicy.GEMscore) ? Object.keys(GEMScoreValueMap).filter(
       (attribute2) => tallyPolicy.GEMscore.includes(attribute2)
@@ -16160,9 +16220,11 @@ function processAttribute({
     participantIds,
     attribute
   });
+  const report = [{ attribute, reversed, groups, idsFilter }];
+  let order;
   if (Object.keys(groups).length > 1 && participantIds.length) {
-    return Object.keys(groups).map((key) => parseFloat(key)).sort((a, b) => reversed ? a - b : b - a).map((key) => groups[key]).map((participantIds2) => {
-      return groupSubSort({
+    order = Object.keys(groups).map((key) => parseFloat(key)).sort((a, b) => reversed ? a - b : b - a).map((key) => groups[key]).map((participantIds2) => {
+      const result = groupSubSort({
         participantResults,
         disableHeadToHead,
         participantIds: participantIds2,
@@ -16170,8 +16232,11 @@ function processAttribute({
         tallyPolicy,
         matchUps
       });
+      report.push(result.report);
+      return result.order;
     }).flat(Infinity);
   }
+  return { order, report };
 }
 function groupSubSort({
   participantResults,
@@ -16181,35 +16246,51 @@ function groupSubSort({
   tallyPolicy,
   matchUps
 }) {
-  if ((participantIds == null ? void 0 : participantIds.length) === 1)
-    return { resolved: true, participantId: participantIds[0] };
+  if ((participantIds == null ? void 0 : participantIds.length) === 1) {
+    const participantId = participantIds[0];
+    return {
+      order: [{ resolved: true, participantId }]
+    };
+  }
   if ((participantIds == null ? void 0 : participantIds.length) === 2 && (!(tallyPolicy == null ? void 0 : tallyPolicy.headToHead) || !tallyPolicy.headToHead.disabled && !disableHeadToHead)) {
     const result2 = headToHeadWinner({ participantIds, participantResults });
     if (result2)
-      return result2;
+      return { order: [result2], headToHeadWinner: result2[0].participantId };
   }
+  const directives = (tallyPolicy == null ? void 0 : tallyPolicy.tallyDirectives) || headToHeadTallyDirectives;
+  const excludedDirectives = [];
+  const report = [];
   let result;
-  ((tallyPolicy == null ? void 0 : tallyPolicy.tallyDirectives) || headToHeadTallyDirectives).filter(
-    ({ maxParticipants }) => (
-      // if maxParticipants is defined, filter out the rule if # of participants is greater than maxParticipants
-      isNumeric(maxParticipants) && (participantIds == null ? void 0 : participantIds.length) > maxParticipants ? false : true
-    )
-  ).every(({ attribute, reversed, idsFilter, disableHeadToHead: disableHeadToHead2 }) => {
-    result = processAttribute({
-      disableHeadToHead: disableHeadToHead2,
-      participantIds,
-      matchUpFormat,
-      tallyPolicy,
-      attribute,
-      idsFilter,
-      matchUps,
-      reversed
-    });
-    return result ? false : true;
-  });
-  if (result)
-    return result;
-  return participantIds == null ? void 0 : participantIds.map((participantId) => ({ participantId }));
+  const filteredDirectives = directives.filter((directive) => {
+    const keepDirective = isNumeric(directive.maxParticipants) && (participantIds == null ? void 0 : participantIds.length) > directive.maxParticipants ? false : true;
+    if (!keepDirective)
+      excludedDirectives.push(directive);
+    return keepDirective;
+  });
+  if (excludedDirectives.length)
+    report.push({ excludedDirectives, participantIds });
+  filteredDirectives.every(
+    ({ attribute, reversed, idsFilter, disableHeadToHead: disableHeadToHead2 }) => {
+      result = processAttribute({
+        disableHeadToHead: disableHeadToHead2,
+        participantIds,
+        matchUpFormat,
+        tallyPolicy,
+        attribute,
+        idsFilter,
+        matchUps,
+        reversed
+      });
+      report.push(result.report);
+      return result.order ? false : true;
+    }
+  );
+  if (result.order)
+    return { order: result.order, report };
+  return {
+    order: participantIds == null ? void 0 : participantIds.map((participantId) => ({ participantId })),
+    report
+  };
 }
 function headToHeadWinner({ participantIds, participantResults }) {
   if (!participantIds)
@@ -16248,6 +16329,7 @@ function getResultsArray({ participantResults, participantIds }) {
 
 function tallyParticipantResults({
   policyDefinitions,
+  generateReport,
   matchUpFormat,
   matchUps = [],
   subOrderMap,
@@ -16260,7 +16342,7 @@ function tallyParticipantResults({
     []
   );
   if (structureIds.length !== 1)
-    return { error: INVALID_VALUES };
+    return { error: INVALID_VALUES, info: "Maximum one structureId" };
   const relevantMatchUps = matchUps.filter(
     (matchUp) => matchUp && matchUp.matchUpStatus !== BYE
   );
@@ -16278,7 +16360,8 @@ function tallyParticipantResults({
     tallyPolicy,
     perPlayer
   });
-  const groupOrder = getGroupOrder({
+  let report, order;
+  const { groupOrder, report: groupOrderReport } = getGroupOrder({
     matchUps: consideredMatchUps,
     participantResults,
     participantsCount,
@@ -16287,6 +16370,8 @@ function tallyParticipantResults({
     subOrderMap
   });
   if (bracketComplete && groupOrder) {
+    report = groupOrderReport;
+    order = groupOrder;
     groupOrder.forEach((finishingPosition) => {
       const { participantId, groupOrder: groupOrder2, rankOrder, subOrder, ties, GEMscore } = finishingPosition;
       const participantResult = participantResults[participantId];
@@ -16299,7 +16384,7 @@ function tallyParticipantResults({
       });
     });
   } else {
-    const provionalOrder = getGroupOrder({
+    const { groupOrder: provisionalOrder, report: provisionalOrderReport } = getGroupOrder({
       requireCompletion: false,
       participantResults,
       participantsCount,
@@ -16308,8 +16393,10 @@ function tallyParticipantResults({
       subOrderMap,
       matchUps
     });
-    if (provionalOrder) {
-      provionalOrder.forEach((finishingPosition) => {
+    report = provisionalOrderReport;
+    order = provisionalOrder;
+    if (provisionalOrder) {
+      provisionalOrder.forEach((finishingPosition) => {
         const { participantId, groupOrder: groupOrder2, GEMscore } = finishingPosition;
         const participantResult = participantResults[participantId];
         Object.assign(participantResult, {
@@ -16319,7 +16406,14 @@ function tallyParticipantResults({
       });
     }
   }
-  return { participantResults, bracketComplete };
+  const result = { participantResults, bracketComplete, report };
+  if (generateReport || getDevContext({ tally: true })) {
+    const readable = getTallyReport({ matchUps, report, order });
+    if (getDevContext({ tally: true }))
+      console.log(readable);
+    result.readableReport = readable;
+  }
+  return result;
 }
 
 const hasParticipantId = (o) => o == null ? void 0 : o.participantId;
@@ -16391,7 +16485,7 @@ function updateAssignmentParticipantResults({
   });
   if (result.error)
     return result;
-  const { participantResults, bracketComplete } = result;
+  const { participantResults, bracketComplete, report } = result;
   const participantIds = Object.keys(participantResults);
   positionAssignments.forEach((assignment) => {
     const { participantId } = assignment;
@@ -16419,7 +16513,11 @@ function updateAssignmentParticipantResults({
     }
   });
   modifyDrawNotice({ drawDefinition });
-  return __spreadProps$j(__spreadValues$B({}, SUCCESS), { participantResults, bracketComplete });
+  return __spreadProps$j(__spreadValues$B({}, SUCCESS), {
+    participantResults,
+    bracketComplete,
+    report
+  });
 }
 
 const toBePlayed = {