tods-competition-factory 0.86.1 → 0.86.2

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

@@ -249,7 +249,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return '0.86.1';
+  return '0.86.2';
 }
 
 const FORMAT_STANDARD = 'SET3-S:6/TB7'; // Best of 3 Tiebreak Sets to 6
@@ -42686,24 +42686,30 @@ const publishingGovernor = {
   unPublishEvent
 };
 
-function analyzeDraws(tournamentRecord) {
+function analyzeDraws({
+  tournamentRecord
+}) {
   var _tournamentRecord$eve;
 
+  if (!tournamentRecord) return {
+    error: MISSING_TOURNAMENT_RECORD
+  };
   const drawsAnalysis = {
-    noPositionsAssigned: 0,
-    // no positions assigned
-    positionsNoOutcomes: 0,
+    positionsNoOutcomes: [],
     // all positions assigned and no outcomes
-    matchPlayDraws: 0,
-    // only first round has active matchUps; some unassigned positions
-    canBePruned: 0,
+    canBePruned: [],
     // partially assigned positions with outcomes => drawSizes can be reduced
-    draws: []
+    matchPlay: [],
+    // only first round has active matchUps; some unassigned positions
+    inactive: [],
+    drawAnalysis: {}
   };
   const drawDefinitions = (_tournamentRecord$eve = tournamentRecord.events) === null || _tournamentRecord$eve === void 0 ? void 0 : _tournamentRecord$eve.map(event => event === null || event === void 0 ? void 0 : event.drawDefinitions).flat().filter(Boolean);
   drawDefinitions.forEach(drawDefinition => {
+    let positionsAssignedCount = 0;
+    let matchUpsWithWinningSideCount = 0;
     const structures = (drawDefinition === null || drawDefinition === void 0 ? void 0 : drawDefinition.structures) || [];
-    const structureData = structures.map(structure => {
+    const structuresData = structures.map(structure => {
       const {
         stage,
         stageSequence,
@@ -42716,6 +42722,16 @@ function analyzeDraws(tournamentRecord) {
         drawDefinition,
         structure
       });
+      const matchUpsWithWinningSide = inContextStructureMatchUps === null || inContextStructureMatchUps === void 0 ? void 0 : inContextStructureMatchUps.filter(({
+        winningSide
+      }) => winningSide);
+      const winningSideCount = matchUpsWithWinningSide.filter(Boolean).length || 0;
+      matchUpsWithWinningSideCount += winningSideCount;
+      const maxWinningSideFirstRoundPosition = Math.max(matchUpsWithWinningSide.filter(({
+        roundNumber
+      }) => roundNumber === 1).map(({
+        roundPosition
+      }) => roundPosition));
       const {
         positionAssignments
       } = getPositionAssignments$1({
@@ -42724,6 +42740,7 @@ function analyzeDraws(tournamentRecord) {
       const positionsAssigned = positionAssignments === null || positionAssignments === void 0 ? void 0 : positionAssignments.filter(({
         participantId
       }) => participantId);
+      positionsAssignedCount += positionsAssigned.length;
       const unassignedPositionsCount = ((positionAssignments === null || positionAssignments === void 0 ? void 0 : positionAssignments.length) || 0) - ((positionsAssigned === null || positionsAssigned === void 0 ? void 0 : positionsAssigned.length) || 0);
       const {
         roundMatchUps,
@@ -42733,13 +42750,16 @@ function analyzeDraws(tournamentRecord) {
       } = getRoundMatchUps$1({
         matchUps: inContextStructureMatchUps
       });
-      const activeRounds = Object.keys(roundProfile).filter(roundNumber => !roundProfile[roundNumber].inactiveRound);
+      const activeRounds = Object.keys(roundProfile).filter(roundNumber => !roundProfile[roundNumber].inactiveRound).map(roundNumber => parseInt(roundNumber));
+      const inactiveRounds = Object.keys(roundProfile).filter(roundNumber => roundProfile[roundNumber].inactiveRound).map(roundNumber => parseInt(roundNumber));
       const inactiveStructure = Object.values(roundProfile).every(profile => profile.inactiveRound);
       return {
         positionsAssignedCount: (positionsAssigned === null || positionsAssigned === void 0 ? void 0 : positionsAssigned.length) || 0,
+        maxWinningSideFirstRoundPosition,
         unassignedPositionsCount,
         inactiveStructure,
         maxMatchUpsCount,
+        inactiveRounds,
         roundMatchUps,
         activeRounds,
         roundNumbers,
@@ -42750,16 +42770,35 @@ function analyzeDraws(tournamentRecord) {
         stage
       };
     });
-    const mainStructure = structureData.find(data => data.orderNumber === 2 && data.stageSequence === 1);
-    const isMatchPlay = mainStructure.activeRounds.length === 1 && parseInt(mainStructure.activeRounds[0]) === 1;
-    const canBePruned = mainStructure.activeRounds.length && mainStructure.roundProfile[1].inActiveCount;
-    if (isMatchPlay) drawsAnalysis.matchPlayDraws += 1;
-    if (canBePruned) drawsAnalysis.canBePruned += 1;
-    drawsAnalysis.draws.push({
-      drawId: drawDefinition.drawId,
-      structureData,
-      isMatchPlay
+    const mainStructure = structuresData.find(data => data.orderNumber === 2 && data.stageSequence === 1);
+    const activeStructuresCount = structuresData.filter(({
+      inactiveStructure
+    }) => !inactiveStructure).length;
+    const {
+      links
+    } = getStructureLinks({
+      drawDefinition,
+      structureId: mainStructure.structureId
     });
+    const isMatchPlay = parseInt(mainStructure.activeRounds[0]) === 1 && mainStructure.activeRounds.length === 1 && activeStructuresCount === 1;
+    const inactiveDraw = structuresData === null || structuresData === void 0 ? void 0 : structuresData.every(({
+      inactiveStructure
+    }) => inactiveStructure);
+    const canBePruned = !links.length && mainStructure.activeRounds.length && (mainStructure.roundProfile[1].inactiveCount || mainStructure.inactiveRounds.length);
+    const drawId = drawDefinition.drawId;
+    if (positionsAssignedCount && !matchUpsWithWinningSideCount) drawsAnalysis.positionsNoOutcomes.push(drawId);
+    if (inactiveDraw) drawsAnalysis.inactive.push(drawId);
+    if (isMatchPlay) drawsAnalysis.matchPlay.push(drawId);
+    if (canBePruned) drawsAnalysis.canBePruned.push(drawId);
+    const drawAnalysis = {
+      matchUpsWithWinningSideCount,
+      positionsAssignedCount,
+      structuresData,
+      inactiveDraw,
+      isMatchPlay,
+      drawId
+    };
+    drawsAnalysis.drawAnalysis[drawId] = drawAnalysis;
   });
   return { ...SUCCESS,
     drawsAnalysis
@@ -42777,7 +42816,7 @@ function checkIsDual(tournamentRecord) {
   const drawDefinition = (event === null || event === void 0 ? void 0 : (_event$drawDefinition = event.drawDefinitions) === null || _event$drawDefinition === void 0 ? void 0 : _event$drawDefinition.length) === 1 && event.drawDefinitions[0];
   const structure = (drawDefinition === null || drawDefinition === void 0 ? void 0 : (_drawDefinition$struc = drawDefinition.structures) === null || _drawDefinition$struc === void 0 ? void 0 : _drawDefinition$struc.length) === 1 && drawDefinition.structures[0];
   const twoDrawPositions = (structure === null || structure === void 0 ? void 0 : (_structure$positionAs = structure.positionAssignments) === null || _structure$positionAs === void 0 ? void 0 : _structure$positionAs.length) === 2;
-  return event.tieFormat && twoTeams && twoDrawPositions;
+  return !!(event.tieFormat && twoTeams && twoDrawPositions);
 }
 
 function analyzeTournament({
@@ -42788,7 +42827,9 @@ function analyzeTournament({
   };
   const {
     drawsAnalysis
-  } = analyzeDraws(tournamentRecord);
+  } = analyzeDraws({
+    tournamentRecord
+  });
   const analysis = {
     isDual: checkIsDual(tournamentRecord),
     drawsAnalysis
@@ -42895,6 +42936,7 @@ const tournamentGovernor = {
   addNotes,
   removeNotes,
   analyzeTournament,
+  analyzeDraws,
   setTournamentName,
   setTournamentNotes,
   setTournamentEndDate,
@@ -46577,6 +46619,179 @@ function deleteAdHocMatchUps(params) {
   return deleteAdHocMatchUps$1(params);
 }
 
+function resetDrawDefinition({
+  drawDefinition,
+  removeScheduling
+}) {
+  if (!drawDefinition) return {
+    error: MISSING_DRAW_DEFINITION
+  }; // for matchups in all structures:
+  // remove all drawPositions which are not first round or fed
+  // remove all extensions
+  // if removeScheudling, remove all scheduling timeItems
+  // for all structures which are NOT QUALIFYING or MAIN { stageSequence: 1 }
+  // remove all positionAssignments that are not BYE
+
+  const matchUpsMap = getMatchUpsMap({
+    drawDefinition
+  });
+
+  const getRawMatchUp = matchUpId => {
+    var _matchUpsMap$drawMatc;
+
+    return matchUpsMap === null || matchUpsMap === void 0 ? void 0 : (_matchUpsMap$drawMatc = matchUpsMap.drawMatchUps) === null || _matchUpsMap$drawMatc === void 0 ? void 0 : _matchUpsMap$drawMatc.find(matchUp => matchUp.matchUpId === matchUpId);
+  };
+
+  for (const structure of drawDefinition.structures || []) {
+    const {
+      positionAssignments,
+      stage,
+      stageSequence
+    } = structure; // reset positionAssignments and seedAssignments where appropriate
+
+    if (positionAssignments && (stageSequence !== 1 || ![QUALIFYING, MAIN].includes(stage))) {
+      structure.positionAssignments = positionAssignments.map(assignment => {
+        delete assignment.participantId;
+        return assignment;
+      });
+      structure.seedAssignments = [];
+    }
+
+    const {
+      matchUps: inContextMatchUps
+    } = getAllStructureMatchUps({
+      inContext: true,
+      matchUpsMap,
+      structure
+    }); // reset all matchUps to initial state
+
+    for (const inContextMatchUp of inContextMatchUps) {
+      var _matchUp$timeItems;
+
+      const {
+        matchUpId,
+        roundNumber,
+        sides
+      } = inContextMatchUp;
+      const matchUp = getRawMatchUp(matchUpId);
+      delete matchUp.extensions;
+      delete matchUp.notes;
+
+      if (matchUp.matchUpStatus !== BYE) {
+        matchUp.matchUpStatus = TO_BE_PLAYED;
+        delete matchUp.matchUpStatusCodes;
+        delete matchUp.matchUpFormat;
+        delete matchUp.winningSide;
+        delete matchUp.score;
+      }
+
+      if (roundNumber && roundNumber > 1 && matchUp.drawPositions) {
+        const fedDrawPositions = sides === null || sides === void 0 ? void 0 : sides.map(({
+          drawPosition,
+          participantFed
+        }) => !participantFed && drawPosition).filter(Boolean);
+        matchUp.drawPositions = matchUp.drawPositions.map(drawPosition => !fedDrawPositions.includes(drawPosition) ? drawPosition : undefined);
+      }
+
+      if (removeScheduling) {
+        delete matchUp.timeItems;
+      } else if ((_matchUp$timeItems = matchUp.timeItems) !== null && _matchUp$timeItems !== void 0 && _matchUp$timeItems.length) {
+        matchUp.timeItems = matchUp.timeItems.filter(timeItem => ![ASSIGN_COURT, ASSIGN_VENUE, ASSIGN_OFFICIAL, SCHEDULED_DATE, SCHEDULED_TIME].includes(timeItem.itemType));
+      }
+
+      modifyMatchUpNotice({
+        drawDefinition,
+        matchUp
+      });
+    }
+  }
+
+  const structureIds = (drawDefinition.structures || []).map(({
+    structureId
+  }) => structureId);
+  modifyDrawNotice({
+    drawDefinition,
+    structureIds
+  });
+  return { ...SUCCESS
+  };
+}
+
+function pruneDrawDefinition({
+  tournamentRecord,
+  drawDefinition,
+  drawId
+}) {
+  if (!tournamentRecord) return {
+    error: MISSING_TOURNAMENT_RECORD
+  };
+  if (!drawDefinition) return {
+    error: MISSING_DRAW_DEFINITION
+  };
+  const {
+    drawsAnalysis
+  } = analyzeDraws({
+    tournamentRecord
+  });
+
+  if (drawsAnalysis.canBePruned.includes(drawId)) {
+    const isMatchPlay = drawsAnalysis.matchPlay.includes(drawId);
+    const drawAnalysis = drawsAnalysis.drawAnalysis[drawId];
+    const {
+      structures: [mainStructure]
+    } = getDrawStructures({
+      drawDefinition,
+      stage: MAIN,
+      stageSequence: 1
+    });
+    const structureData = drawAnalysis.structuresData.find(({
+      structureId
+    }) => mainStructure.structureId === structureId);
+    const matchUps = mainStructure.matchUps || [];
+    const relevantMatchUps = matchUps.sort((a, b) => a.roundPosition - b.roundPosition).filter(({
+      roundNumber
+    }) => !structureData.inactiveRounds.includes(roundNumber));
+    const relevantMatchUpIds = relevantMatchUps.map(getMatchUpId);
+    const deletedMatchUpIds = matchUps.map(getMatchUpId).filter(matchUpId => !relevantMatchUpIds.includes(matchUpId)); // only ifMatchPlay can the positionAssignments be reallocated
+
+    if (isMatchPlay) {
+      const matchPlayMatchUps = relevantMatchUps.sort((a, b) => a.roundPosition - b.roundPosition).filter(({
+        roundNumber
+      }) => !structureData.inactiveRounds.includes(roundNumber)).filter(({
+        winningSide
+      }) => !isMatchPlay || winningSide);
+      const matchPlayMatchUpIds = matchPlayMatchUps.map(getMatchUpId);
+      const matchUpIdsToDelete = relevantMatchUpIds.filter(matchUpId => !matchPlayMatchUpIds.includes(matchUpId));
+      deletedMatchUpIds.push(...matchUpIdsToDelete);
+      const existingDrawPositionPairings = matchPlayMatchUps.map(({
+        drawPositions
+      }) => drawPositions);
+      const existingDrawPositions = existingDrawPositionPairings.flat();
+      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;
+      });
+      mainStructure.positionAssignments = updatedPositionAssignments;
+      mainStructure.matchUps = matchPlayMatchUps;
+    }
+
+    deleteMatchUpsNotice({
+      drawDefinition,
+      matchUpIds: deletedMatchUpIds
+    });
+    modifyDrawNotice({
+      drawDefinition
+    });
+  }
+
+  return { ...SUCCESS
+  };
+}
+
 /**
  *
  * @param {object} orderedDrawIdsMap - required - mapping of ALL present drawIds => { [drawId]: drawOrder }
@@ -47026,6 +47241,8 @@ const eventGovernor = {
   deleteFlightAndFlightDraw,
   generateFlightProfile,
   attachFlightProfile,
+  resetDrawDefinition,
+  pruneDrawDefinition,
   updateDrawIdsOrder,
   getFlightProfile,
   getScaledEntries,