tods-competition-factory 0.96.0 → 0.98.2

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

@@ -249,7 +249,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return '0.96.0';
+  return '0.98.2';
 }
 
 const FORMAT_STANDARD = 'SET3-S:6/TB7'; // Best of 3 Tiebreak Sets to 6
@@ -3920,8 +3920,9 @@ function generateTieMatchUpScore({
       sideWins: [0, 0],
       values: [0, 0]
     }
-  })));
-  const groupValueNumbers = Object.keys(groupValueGroups);
+  }))); // must be coerced to numbers
+
+  const groupValueNumbers = Object.keys(groupValueGroups).map(num => parseInt(num));
 
   for (const collectionDefinition of collectionDefinitions) {
     const collectionMatchUps = tieMatchUps.filter(matchUp => matchUp.collectionId === collectionDefinition.collectionId); // keep track of the values derived from matchUps
@@ -20739,8 +20740,10 @@ function swapWinnerLoser(params) {
 function setMatchUpStatus$2(params) {
   var _inContextMatchUp$dra, _matchUp$sides;
 
-  // matchUpStatus in params is the new status
+  // always clear score if DOUBLE_WALKOVER or WALKOVER
+  if ([WALKOVER$1, DOUBLE_WALKOVER].includes(params.matchUpStatus)) params.score = undefined; // matchUpStatus in params is the new status
   // winningSide in params is new winningSide
+
   const {
     allowChangePropagation = undefined,
     // factory default
@@ -33557,7 +33560,6 @@ function generateVoluntaryConsolationStructure$1({
   drawSize,
   event
 }) {
-  const stage = VOLUNTARY_CONSOLATION;
   if (!drawDefinition) return {
     error: MISSING_DRAW_DEFINITION
   };
@@ -33568,13 +33570,14 @@ function generateVoluntaryConsolationStructure$1({
     matchUpType,
     drawSize
   });
+  const stage = VOLUNTARY_CONSOLATION;
   const structure = structureTemplate({
-    stage,
-    matchUps,
-    matchUpType,
-    structureName,
     structureAbbreviation,
-    structureId
+    structureName,
+    structureId,
+    matchUpType,
+    matchUps,
+    stage
   });
   drawDefinition.structures.push(structure);
 
@@ -47200,6 +47203,94 @@ function generateVoluntaryConsolationStructure(params) {
   });
 }
 
+/**
+ *
+ * @param {object} orderedDrawIdsMap - required - mapping of ALL present drawIds => { [drawId]: drawOrder }
+ */
+
+function updateDrawIdsOrder({
+  event,
+  orderedDrawIdsMap
+}) {
+  var _event$drawDefinition, _flightProfile$flight;
+
+  if (typeof event !== 'object') return {
+    error: MISSING_EVENT
+  };
+  if (!orderedDrawIdsMap) return {
+    error: MISSING_VALUE,
+    message: 'Missing drawIdsOrderMap'
+  };
+  if (typeof orderedDrawIdsMap !== 'object') return {
+    error: INVALID_VALUES,
+    message: 'orderedDrawIdsMap must be an object'
+  };
+  const drawOrders = Object.values(orderedDrawIdsMap);
+  const validDrawOrders = drawOrders.every(drawOrder => !isNaN(drawOrder));
+  if (!validDrawOrders) return {
+    error: INVALID_VALUES,
+    message: 'drawOrder must be numeric'
+  };
+  if (unique(drawOrders).length !== drawOrders.length) return {
+    error: INVALID_VALUES,
+    message: 'drawOrder values must be unique'
+  };
+
+  if ((_event$drawDefinition = event.drawDefinitions) !== null && _event$drawDefinition !== void 0 && _event$drawDefinition.length) {
+    const drawIds = (event.drawDefinitions || []).map(({
+      drawId
+    }) => drawId);
+    const orderedDrawIds = Object.keys(orderedDrawIdsMap);
+    if (intersection(drawIds, orderedDrawIds).length !== drawIds.length) return {
+      error: INVALID_VALUES,
+      message: 'Missing drawIds'
+    };
+    event.drawDefinitions.forEach(drawDefinition => {
+      drawDefinition.drawOrder = orderedDrawIdsMap[drawDefinition.drawId];
+    });
+  }
+
+  const {
+    flightProfile
+  } = getFlightProfile({
+    event
+  });
+  flightProfile === null || flightProfile === void 0 ? void 0 : (_flightProfile$flight = flightProfile.flights) === null || _flightProfile$flight === void 0 ? void 0 : _flightProfile$flight.forEach(flight => {
+    flight.flightNumber = orderedDrawIdsMap[flight.drawId];
+  });
+  return SUCCESS;
+}
+
+function refreshEventDrawOrder({
+  tournamentRecord,
+  event
+}) {
+  var _event$drawDefinition;
+
+  if (!tournamentRecord) return {
+    error: MISSING_TOURNAMENT_RECORD
+  };
+  if (!event) return {
+    error: MISSING_EVENT
+  };
+  const {
+    flightProfile
+  } = getFlightProfile({
+    event
+  }); // if there is a flightProfile, derive order from that, otherwise use drawDefinitions array
+
+  const orderedDrawIdsMap = flightProfile !== null && flightProfile !== void 0 && flightProfile.flights ? Object.assign({}, ...flightProfile.flights.sort((a, b) => a.flightNumber - b.flightNumber).map((flight, i) => ({
+    [flight.drawId]: i + 1
+  }))) : (_event$drawDefinition = event.drawDefinitions) !== null && _event$drawDefinition !== void 0 && _event$drawDefinition.length ? Object.assign({}, ...event.drawDefinitions.sort((a, b) => a.drawOrder - b.drawOrder).map((drawDefinition, i) => ({
+    [drawDefinition.drawId]: i + 1
+  }))) : undefined;
+  return orderedDrawIdsMap ? updateDrawIdsOrder({
+    event,
+    orderedDrawIdsMap
+  }) : { ...SUCCESS
+  };
+}
+
 function deleteFlightAndFlightDraw({
   tournamentRecord,
   event,
@@ -47247,7 +47338,10 @@ function deleteFlightAndFlightDraw({
     drawIds: [drawId],
     auditData
   });
-  return SUCCESS;
+  return refreshEventDrawOrder({
+    tournamentRecord,
+    event
+  });
 }
 
 function generateAdHocMatchUps(params) {
@@ -47636,64 +47730,6 @@ function pruneDrawDefinition({
   };
 }
 
-/**
- *
- * @param {object} orderedDrawIdsMap - required - mapping of ALL present drawIds => { [drawId]: drawOrder }
- */
-
-function updateDrawIdsOrder({
-  event,
-  orderedDrawIdsMap
-}) {
-  var _event$drawDefinition, _flightProfile$flight;
-
-  if (typeof event !== 'object') return {
-    error: MISSING_EVENT
-  };
-  if (!orderedDrawIdsMap) return {
-    error: MISSING_VALUE,
-    message: 'Missing drawIdsOrderMap'
-  };
-  if (typeof orderedDrawIdsMap !== 'object') return {
-    error: INVALID_VALUES,
-    message: 'orderedDrawIdsMap must be an object'
-  };
-  const drawOrders = Object.values(orderedDrawIdsMap);
-  const validDrawOrders = drawOrders.every(drawOrder => !isNaN(drawOrder));
-  if (!validDrawOrders) return {
-    error: INVALID_VALUES,
-    message: 'drawOrder must be numeric'
-  };
-  if (unique(drawOrders).length !== drawOrders.length) return {
-    error: INVALID_VALUES,
-    message: 'drawOrder values must be unique'
-  };
-
-  if ((_event$drawDefinition = event.drawDefinitions) !== null && _event$drawDefinition !== void 0 && _event$drawDefinition.length) {
-    const drawIds = (event.drawDefinitions || []).map(({
-      drawId
-    }) => drawId);
-    const orderedDrawIds = Object.keys(orderedDrawIdsMap);
-    if (intersection(drawIds, orderedDrawIds).length !== drawIds.length) return {
-      error: INVALID_VALUES,
-      message: 'Missing drawIds'
-    };
-    event.drawDefinitions.forEach(drawDefinition => {
-      drawDefinition.drawOrder = orderedDrawIdsMap[drawDefinition.drawId];
-    });
-  }
-
-  const {
-    flightProfile
-  } = getFlightProfile({
-    event
-  });
-  flightProfile === null || flightProfile === void 0 ? void 0 : (_flightProfile$flight = flightProfile.flights) === null || _flightProfile$flight === void 0 ? void 0 : _flightProfile$flight.forEach(flight => {
-    flight.flightNumber = orderedDrawIdsMap[flight.drawId];
-  });
-  return SUCCESS;
-}
-
 function setOrderOfFinish(params) {
   return setOrderOfFinish$1(params);
 }
@@ -48084,6 +48120,7 @@ const eventGovernor = {
   deleteFlightProfileAndFlightDraws,
   deleteFlightAndFlightDraw,
   generateFlightProfile,
+  refreshEventDrawOrder,
   attachFlightProfile,
   resetDrawDefinition,
   pruneDrawDefinition,
@@ -53179,33 +53216,45 @@ function genParticipantId({
 }
 
 function processTieFormat({
-  tieFormat,
+  alternatesCount = 0,
   tieFormatName,
-  drawSize,
-  alternatesCount = 0
+  tieFormat,
+  drawSize
 }) {
   var _tieFormat, _tieFormat$collection;
 
   let maxDoublesCount = 0,
       maxSinglesCount = 0;
+  let singlesMatchUpTotal = 0,
+      doublesMatchUpTotal = 0;
+  let categories = 0;
   tieFormat = typeof tieFormat === 'object' ? tieFormat : tieFormatDefaults({
     namedFormat: tieFormatName
   });
-  (_tieFormat = tieFormat) === null || _tieFormat === void 0 ? void 0 : (_tieFormat$collection = _tieFormat.collectionDefinitions) === null || _tieFormat$collection === void 0 ? void 0 : _tieFormat$collection.forEach(collectionDefinition => {
-    // ensure every collectionDefinition has a collectionId
-    if (!collectionDefinition.collectionId) collectionDefinition.collectionId = UUID();
+  (_tieFormat = tieFormat) === null || _tieFormat === void 0 ? void 0 : (_tieFormat$collection = _tieFormat.collectionDefinitions) === null || _tieFormat$collection === void 0 ? void 0 : _tieFormat$collection.filter(Boolean).forEach(collectionDefinition => {
+    const {
+      category,
+      collectionId,
+      matchUpType,
+      matchUpCount
+    } = collectionDefinition;
+    if (category) categories += 1; // ensure every collectionDefinition has a collectionId
+
+    if (!collectionId) collectionDefinition.collectionId = UUID();
 
-    if ((collectionDefinition === null || collectionDefinition === void 0 ? void 0 : collectionDefinition.matchUpType) === DOUBLES$1) {
-      const doublesCount = collectionDefinition.matchUpCount;
+    if (matchUpType === DOUBLES$1) {
+      const doublesCount = matchUpCount;
+      doublesMatchUpTotal += matchUpCount;
       maxDoublesCount = Math.max(maxDoublesCount, doublesCount);
     }
 
-    if ((collectionDefinition === null || collectionDefinition === void 0 ? void 0 : collectionDefinition.matchUpType) === SINGLES$1) {
-      const singlescount = collectionDefinition.matchUpCount;
+    if (matchUpType === SINGLES$1) {
+      const singlescount = matchUpCount;
+      singlesMatchUpTotal += matchUpCount;
       maxSinglesCount = Math.max(maxSinglesCount, singlescount);
     }
   });
-  const teamSize = Math.max(maxSinglesCount, maxDoublesCount * 2);
+  const teamSize = categories ? Math.max(singlesMatchUpTotal, doublesMatchUpTotal * 2) : Math.max(maxSinglesCount, maxDoublesCount * 2);
   const maxDoublesDraw = maxDoublesCount * (drawSize + alternatesCount);
   const maxSinglesDraw = maxSinglesCount * (drawSize + alternatesCount);
   return {