tods-competition-factory 0.86.2 → 0.86.3

package/dist/tods-competition-factory.development.cjs.js

@@ -249,7 +249,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return '0.86.2';
+  return '0.86.3';
 }
 
 const FORMAT_STANDARD = 'SET3-S:6/TB7'; // Best of 3 Tiebreak Sets to 6
@@ -10040,11 +10040,15 @@ function getMappedStructureMatchUps({
     } = mappedMatchUps[itemStructureId];
 
     if (inContext) {
-      return matchUps.map(matchUp => Object.assign(makeDeepCopy(matchUp, true, true), {
-        containerStructureId: structureId,
-        structureId: itemStructureId,
-        structureName
-      }));
+      const inContextMatchUps = matchUps.map(matchUp => {
+        const inContextMatchUp = Object.assign(makeDeepCopy(matchUp, true, true), {
+          containerStructureId: structureId,
+          structureId: itemStructureId,
+          structureName
+        });
+        return inContextMatchUp;
+      });
+      return inContextMatchUps;
     } else {
       return matchUps;
     }
@@ -11119,22 +11123,28 @@ function getOrderedDrawPositions({
 }
 
 function isLucky({
+  hasOddMatchUpsCount,
   drawDefinition,
+  roundMatchUps,
   structure
 }) {
-  var _roundMatchUps$, _roundMatchUps$2;
+  var _roundMatchUps, _roundMatchUps$, _roundMatchUps2, _roundMatchUps2$;
 
   if (!structure) return false;
-  const {
-    hasOddMatchUpsCount,
-    roundMatchUps
-  } = getRoundMatchUps$1({
-    matchUps: structure.matchUps || []
-  });
-  const hasFirstRoundDrawPositions = !!(roundMatchUps !== null && roundMatchUps !== void 0 && (_roundMatchUps$ = roundMatchUps[1]) !== null && _roundMatchUps$ !== void 0 && _roundMatchUps$.find(({
+
+  if (!roundMatchUps) {
+    ({
+      hasOddMatchUpsCount,
+      roundMatchUps
+    } = getRoundMatchUps$1({
+      matchUps: structure.matchUps || []
+    }));
+  }
+
+  const hasFirstRoundDrawPositions = !!((_roundMatchUps = roundMatchUps) !== null && _roundMatchUps !== void 0 && (_roundMatchUps$ = _roundMatchUps[1]) !== null && _roundMatchUps$ !== void 0 && _roundMatchUps$.find(({
     drawPositions
   }) => drawPositions));
-  const noSecondRoundDrawPositions = !(roundMatchUps !== null && roundMatchUps !== void 0 && (_roundMatchUps$2 = roundMatchUps[2]) !== null && _roundMatchUps$2 !== void 0 && _roundMatchUps$2.find(({
+  const noSecondRoundDrawPositions = !((_roundMatchUps2 = roundMatchUps) !== null && _roundMatchUps2 !== void 0 && (_roundMatchUps2$ = _roundMatchUps2[2]) !== null && _roundMatchUps2$ !== void 0 && _roundMatchUps2$.find(({
     drawPositions
   }) => drawPositions));
   return hasOddMatchUpsCount && !(structure !== null && structure !== void 0 && structure.structures) && hasFirstRoundDrawPositions && noSecondRoundDrawPositions && !(drawDefinition !== null && drawDefinition !== void 0 && drawDefinition.drawType && drawDefinition.drawType !== LUCKY_DRAW);
@@ -11155,16 +11165,10 @@ function getRoundContextProfile({
   structure,
   matchUps
 }) {
-  const roundNamingProfile = {};
-  const isRoundRobin = structure.structures;
-  const isAdHocStructure = isAdHoc({
-    structure
-  });
-  const isLuckyStructure = isLucky({
-    structure
-  });
   const {
-    roundProfile
+    hasOddMatchUpsCount,
+    roundProfile,
+    roundMatchUps
   } = getRoundMatchUps$1({
     matchUps
   });
@@ -11172,6 +11176,16 @@ function getRoundContextProfile({
     structureAbbreviation,
     stage
   } = structure;
+  const isAdHocStructure = isAdHoc({
+    structure
+  });
+  const isLuckyStructure = isLucky({
+    hasOddMatchUpsCount,
+    roundMatchUps,
+    structure
+  });
+  const isRoundRobin = structure.structures;
+  const roundNamingProfile = {};
   const defaultRoundNamingPolicy = POLICY_ROUND_NAMING_DEFAULT[POLICY_TYPE_ROUND_NAMING];
   const roundNamingMap = (roundNamingPolicy === null || roundNamingPolicy === void 0 ? void 0 : roundNamingPolicy.roundNamingMap) || defaultRoundNamingPolicy.roundNamingMap || {};
   const abbreviatedRoundNamingMap = (roundNamingPolicy === null || roundNamingPolicy === void 0 ? void 0 : roundNamingPolicy.abbreviatedRoundNamingMap) || defaultRoundNamingPolicy.abbreviatedRoundNamingMap || {};
@@ -11216,12 +11230,14 @@ function getRoundContextProfile({
 
   return {
     roundNamingProfile,
-    roundProfile
+    roundProfile,
+    roundMatchUps
   };
 }
 
 function getDrawPositionsRanges({
   drawDefinition,
+  roundProfile,
   structureId,
   matchUpsMap
 }) {
@@ -11233,15 +11249,19 @@ function getDrawPositionsRanges({
   if (!structureId) return {
     error: MISSING_STRUCTURE_ID
   };
-  const structureMatchUps = getMappedStructureMatchUps({
-    matchUpsMap,
-    structureId
-  });
-  const {
-    roundProfile
-  } = getRoundMatchUps$1({
-    matchUps: structureMatchUps
-  });
+
+  if (!roundProfile) {
+    const structureMatchUps = getMappedStructureMatchUps({
+      matchUpsMap,
+      structureId
+    });
+    ({
+      roundProfile
+    } = getRoundMatchUps$1({
+      matchUps: structureMatchUps
+    }));
+  }
+
   const firstRoundFirstDrawPosition = Math.min(...(((_roundProfile$ = roundProfile[1]) === null || _roundProfile$ === void 0 ? void 0 : _roundProfile$.drawPositions) || []));
   const firstRoundFirstDrawPositionOffset = (firstRoundFirstDrawPosition || 1) - 1;
   const roundNumbers = Object.keys(roundProfile);
@@ -11695,9 +11715,9 @@ function getAllStructureMatchUps({
 
   if (!targetEvent || !targetStructure || !targetDraw) {
     return {
-      matchUps: [],
       collectionPositionMatchUps,
-      roundMatchUps
+      roundMatchUps,
+      matchUps: []
     };
   } // TODO: code is shared with matchUpActions.js
   // TODO: extend testing to restrict for MAIN while leaving consolation unrestricted
@@ -11755,15 +11775,17 @@ function getAllStructureMatchUps({
     inContext
   });
   const roundNamingPolicy = appliedPolicies && appliedPolicies[POLICY_TYPE_ROUND_NAMING];
-  const {
-    roundNamingProfile,
-    roundProfile
-  } = getRoundContextProfile({
+  const result = getRoundContextProfile({
     roundNamingPolicy,
     drawDefinition,
     structure,
     matchUps
   });
+  const {
+    roundNamingProfile,
+    roundProfile
+  } = result;
+  roundMatchUps = result.roundMatchUps;
 
   if (matchUpFilters) {
     matchUps = filterMatchUps({
@@ -11788,6 +11810,7 @@ function getAllStructureMatchUps({
       drawPositionsRanges
     } = getDrawPositionsRanges({
       drawDefinition,
+      roundProfile,
       matchUpsMap,
       structureId
     });
@@ -11834,16 +11857,22 @@ function getAllStructureMatchUps({
     });
   }
 
-  ({
-    roundMatchUps
-  } = getRoundMatchUps$1({
-    matchUps
-  }));
-  ({
-    collectionPositionMatchUps
-  } = getCollectionPositionMatchUps({
-    matchUps
-  }));
+  if (matchUpFilters !== null && matchUpFilters !== void 0 && matchUpFilters.matchUpTypes || matchUpFilters !== null && matchUpFilters !== void 0 && matchUpFilters.matchUpIds || inContext) {
+    ({
+      roundMatchUps
+    } = getRoundMatchUps$1({
+      matchUps
+    }));
+  }
+
+  if (structure.tieFormat || drawDefinition !== null && drawDefinition !== void 0 && drawDefinition.tieFormat || event !== null && event !== void 0 && event.tieFormat) {
+    ({
+      collectionPositionMatchUps
+    } = getCollectionPositionMatchUps({
+      matchUps
+    }));
+  }
+
   if (roundFilter) matchUps = (_matchUps3 = matchUps) === null || _matchUps3 === void 0 ? void 0 : _matchUps3.filter(matchUp => matchUp.roundNumber === roundFilter);
   return {
     matchUps,
@@ -42708,6 +42737,7 @@ function analyzeDraws({
   drawDefinitions.forEach(drawDefinition => {
     let positionsAssignedCount = 0;
     let matchUpsWithWinningSideCount = 0;
+    let matchUpsNoOutcomeCount = 0;
     const structures = (drawDefinition === null || drawDefinition === void 0 ? void 0 : drawDefinition.structures) || [];
     const structuresData = structures.map(structure => {
       const {
@@ -42727,6 +42757,7 @@ function analyzeDraws({
       }) => winningSide);
       const winningSideCount = matchUpsWithWinningSide.filter(Boolean).length || 0;
       matchUpsWithWinningSideCount += winningSideCount;
+      matchUpsNoOutcomeCount += inContextStructureMatchUps.length - matchUpsWithWinningSideCount;
       const maxWinningSideFirstRoundPosition = Math.max(matchUpsWithWinningSide.filter(({
         roundNumber
       }) => roundNumber === 1).map(({
@@ -42792,6 +42823,7 @@ function analyzeDraws({
     if (canBePruned) drawsAnalysis.canBePruned.push(drawId);
     const drawAnalysis = {
       matchUpsWithWinningSideCount,
+      matchUpsNoOutcomeCount,
       positionsAssignedCount,
       structuresData,
       inactiveDraw,
@@ -46718,6 +46750,8 @@ function resetDrawDefinition({
 }
 
 function pruneDrawDefinition({
+  matchPlayDrawPositions = true,
+  // when simply extracting matchUps for aggregation, drawPositions are unnecessary
   tournamentRecord,
   drawDefinition,
   drawId
@@ -46728,6 +46762,7 @@ function pruneDrawDefinition({
   if (!drawDefinition) return {
     error: MISSING_DRAW_DEFINITION
   };
+  let relevantMatchUps = [];
   const {
     drawsAnalysis
   } = analyzeDraws({
@@ -46740,15 +46775,15 @@ function pruneDrawDefinition({
     const {
       structures: [mainStructure]
     } = getDrawStructures({
+      stageSequence: 1,
       drawDefinition,
-      stage: MAIN,
-      stageSequence: 1
+      stage: MAIN
     });
     const structureData = drawAnalysis.structuresData.find(({
       structureId
     }) => mainStructure.structureId === structureId);
     const matchUps = mainStructure.matchUps || [];
-    const relevantMatchUps = matchUps.sort((a, b) => a.roundPosition - b.roundPosition).filter(({
+    relevantMatchUps = matchUps.sort((a, b) => a.roundPosition - b.roundPosition).filter(({
       roundNumber
     }) => !structureData.inactiveRounds.includes(roundNumber));
     const relevantMatchUpIds = relevantMatchUps.map(getMatchUpId);
@@ -46770,13 +46805,26 @@ function pruneDrawDefinition({
       const drawPositionsMap = Object.assign({}, ...existingDrawPositions.map((drawPosition, i) => ({
         [drawPosition]: i + 1
       })));
-      matchPlayMatchUps.forEach(matchUp => matchUp.drawPositions = matchUp.drawPositions.map(drawPosition => drawPositionsMap[drawPosition]));
-      const updatedPositionAssignments = mainStructure.positionAssignments.filter(assignment => existingDrawPositions.includes(assignment.drawPosition)).map(assignment => {
-        assignment.drawPosition = drawPositionsMap[assignment.drawPosition];
-        return assignment;
+      matchPlayMatchUps.forEach(matchUp => {
+        if (matchPlayDrawPositions) {
+          matchUp.drawPositions = matchUp.drawPositions.map(drawPosition => drawPositionsMap[drawPosition]);
+        } else {
+          delete matchUp.drawPositions;
+        }
       });
-      mainStructure.positionAssignments = updatedPositionAssignments;
+
+      if (matchPlayDrawPositions) {
+        const updatedPositionAssignments = mainStructure.positionAssignments.filter(assignment => existingDrawPositions.includes(assignment.drawPosition)).map(assignment => {
+          assignment.drawPosition = drawPositionsMap[assignment.drawPosition];
+          return assignment;
+        });
+        mainStructure.positionAssignments = updatedPositionAssignments;
+      } else {
+        mainStructure.positionAssignments = [];
+      }
+
       mainStructure.matchUps = matchPlayMatchUps;
+      relevantMatchUps = matchPlayMatchUps;
     }
 
     deleteMatchUpsNotice({
@@ -46788,7 +46836,8 @@ function pruneDrawDefinition({
     });
   }
 
-  return { ...SUCCESS
+  return { ...SUCCESS,
+    matchUps: relevantMatchUps
   };
 }