tods-competition-factory 1.6.22 → 1.6.24

package/dist/index.mjs

@@ -329,7 +329,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.6.22";
+  return "1.6.24";
 }
 
 function getObjectTieFormat(obj) {
@@ -402,6 +402,9 @@ function unique(arr) {
 function shuffleArray(arr) {
   return arr.map((a) => [Math.random(), a]).sort((a, b) => a[0] - b[0]).map((a) => a[1]);
 }
+function numericSortValue(v) {
+  return isConvertableInteger(v) ? v : Infinity;
+}
 function instanceCount(values) {
   return values.reduce((a, c) => {
     if (!a[c])
@@ -3700,6 +3703,7 @@ const POLICY_TYPE_PARTICIPANT = "participant";
 const POLICY_TYPE_PROGRESSION = "progression";
 const POLICY_TYPE_SCHEDULING = "scheduling";
 const POLICY_TYPE_AVOIDANCE = "avoidance";
+const POLICY_TYPE_DISPLAY = "display";
 const POLICY_TYPE_SCORING = "scoring";
 const POLICY_TYPE_SEEDING = "seeding";
 const POLICY_TYPE_FEED_IN = "feedIn";
@@ -3717,6 +3721,7 @@ const policyConstants = {
   POLICY_TYPE_PROGRESSION,
   POLICY_TYPE_SCHEDULING,
   POLICY_TYPE_AVOIDANCE,
+  POLICY_TYPE_DISPLAY,
   POLICY_TYPE_FEED_IN,
   POLICY_TYPE_SCORING,
   POLICY_TYPE_SEEDING,
@@ -9144,25 +9149,25 @@ function targetByRoundOutcome({
     matchUp,
     targetLinks: { loserTargetLink, winnerTargetLink, byeTargetLink },
     targetMatchUps: {
-      byeMatchUp,
-      loserMatchUp,
-      winnerMatchUp,
-      byeTargetDrawPosition,
-      loserTargetDrawPosition,
-      winnerTargetDrawPosition,
-      byeMatchUpDrawPositionIndex,
+      winnerMatchUpDrawPositionIndex,
       loserMatchUpDrawPositionIndex,
-      winnerMatchUpDrawPositionIndex
+      byeMatchUpDrawPositionIndex,
+      winnerTargetDrawPosition,
+      loserTargetDrawPosition,
+      byeTargetDrawPosition,
+      winnerMatchUp,
+      loserMatchUp,
+      byeMatchUp
     },
     targetMatchUpIds: !!(winnerMatchUpId || loserMatchUpId)
   });
 }
 function targetByWinRatio({ matchUp }) {
   return {
-    matchUp,
     targetLinks: { loserTargetLink: void 0, winnerTargetLink: void 0 },
     // returned for testing
-    targetMatchUps: { loserMatchUp: void 0, winnerMatchUp: void 0 }
+    targetMatchUps: { loserMatchUp: void 0, winnerMatchUp: void 0 },
+    matchUp
   };
 }
 
@@ -36250,7 +36255,7 @@ function modifyVenue$1({
   venue && validReplacementAttributes.forEach(
     (attribute) => Object.assign(venue, { [attribute]: modifications[attribute] })
   );
-  const existingCourtIds = venue?.courts?.map((court) => court.courtId) || [];
+  const existingCourtIds = venue?.courts?.map((court) => court.courtId) ?? [];
   const courtIdsToModify = modifications.courts?.map((court) => court.courtId) || [];
   const courtIdsToDelete = existingCourtIds.filter(
     (courtId) => !courtIdsToModify.includes(courtId)
@@ -36265,7 +36270,7 @@ function modifyVenue$1({
         tournamentRecord,
         venueMatchUps
       });
-      return result2.matchUps?.length || 0;
+      return result2.matchUps?.length ?? 0;
     }).reduce((a, b) => a + b);
     if (venue && (!scheduleDeletionsCount || force)) {
       venue.courts = venue.courts?.filter(
@@ -41522,6 +41527,36 @@ function generateAndPopulatePlayoffStructures(params) {
     if (result.error)
       console.log(result.error);
   });
+  const byeMatchUps = inContextDrawMatchUps?.filter(
+    (matchUp) => matchUp.matchUpStatus === BYE && matchUp.structureId === sourceStructureId
+  );
+  byeMatchUps?.forEach((matchUp) => {
+    const { matchUpId } = matchUp;
+    const targetData = positionTargets({
+      inContextDrawMatchUps,
+      drawDefinition,
+      matchUpId
+    });
+    const {
+      targetLinks: { loserTargetLink },
+      targetMatchUps: {
+        loserMatchUpDrawPositionIndex,
+        // only present when positionTargets found without loserMatchUpId
+        loserMatchUp
+      }
+    } = targetData;
+    const targetStructureId = loserTargetLink.target.structureId;
+    const targetDrawPosition = loserMatchUp.drawPositions[loserMatchUpDrawPositionIndex];
+    const result = assignDrawPositionBye$1({
+      drawPosition: targetDrawPosition,
+      structureId: targetStructureId,
+      tournamentRecord,
+      drawDefinition,
+      event
+    });
+    if (result.error)
+      console.log(result.error);
+  });
   const matchUpModifications = [];
   const goesToMap = addGoesTo({
     inContextDrawMatchUps,
@@ -42140,7 +42175,7 @@ function attachStructures$1({
   if (!drawDefinition)
     return { error: MISSING_DRAW_DEFINITION };
   if (!Array.isArray(structures) || !Array.isArray(links))
-    return { error: INVALID_VALUES };
+    return decorateResult({ result: { error: INVALID_VALUES } });
   const stack = "attachStructures";
   const linkHash = (link) => [
     link.source.structureId,
@@ -42311,6 +42346,27 @@ function deleteAdHocMatchUps$1({
   return { ...SUCCESS };
 }
 
+function setStructureOrder({ drawDefinition, orderMap }) {
+  if (!drawDefinition)
+    return { error: MISSING_DRAW_DEFINITION };
+  if (typeof orderMap !== "object" || !Object.values(orderMap).every((val) => isConvertableInteger(val)))
+    decorateResult({
+      result: { error: INVALID_VALUES },
+      context: { orderMap }
+    });
+  if (!drawDefinition.structures)
+    drawDefinition.structures = [];
+  drawDefinition.structures.forEach((structure) => {
+    const structureOrder = orderMap[structure.structureId];
+    if (structureOrder)
+      structure.structureOrder = structureOrder;
+  });
+  drawDefinition.structures.sort(
+    (a, b) => numericSortValue(a.structureOrder) - numericSortValue(b.structureOrder)
+  );
+  return { ...SUCCESS };
+}
+
 function renameStructures$1({ drawDefinition, structureDetails }) {
   if (!isObject(structureDetails))
     return { error: INVALID_VALUES };
@@ -42555,6 +42611,7 @@ const structureGovernor = {
   generateAndPopulatePlayoffStructures,
   attachPlayoffStructures: attachPlayoffStructures$1,
   addPlayoffStructures: addPlayoffStructures$1,
+  setStructureOrder,
   renameStructures: renameStructures$1,
   generateQualifyingStructure: generateQualifyingStructure$1,
   attachQualifyingStructure: attachQualifyingStructure$1,
@@ -44507,8 +44564,9 @@ function eliminationSwap({
     return { ...SUCCESS };
   if (assignments.filter(({ qualifier }) => qualifier).length === 2)
     return { ...SUCCESS };
+  const isQualifierSwap = assignments.some(({ qualifier }) => qualifier);
   const isByeSwap = assignments.some(({ bye }) => bye);
-  if (isByeSwap) {
+  if (isByeSwap && !isQualifierSwap) {
     return swapParticipantIdWithBYE({
       inContextDrawMatchUps,
       tournamentRecord,
@@ -44519,7 +44577,7 @@ function eliminationSwap({
       event
     });
   } else {
-    return eliminationParticipantSwap({
+    return eliminationPosiitonSwap({
       inContextDrawMatchUps,
       tournamentRecord,
       drawDefinition,
@@ -44588,7 +44646,7 @@ function swapParticipantIdWithBYE({
     return result;
   return { ...SUCCESS };
 }
-function eliminationParticipantSwap({
+function eliminationPosiitonSwap({
   inContextDrawMatchUps,
   tournamentRecord,
   drawDefinition,
@@ -44649,8 +44707,9 @@ function roundRobinSwap({
     structure,
     event
   });
+  const isQualifierSwap = assignments.some(({ qualifier }) => qualifier);
   const isByeSwap = assignments.some(({ bye }) => bye);
-  if (isByeSwap) {
+  if (isByeSwap && !isQualifierSwap) {
     swapParticipantIdWithBYE({
       inContextDrawMatchUps,
       tournamentRecord,
@@ -44918,10 +44977,19 @@ function generateDrawMaticRound({
   eventType,
   structure
 }) {
+  if (!drawDefinition)
+    return { error: MISSING_DRAW_DEFINITION };
+  if (!structure && !structureId)
+    return { error: STRUCTURE_NOT_FOUND };
+  if (!structure) {
+    structure = findStructure({ drawDefinition, structureId }).structure;
+  }
+  if (!isObject(structure))
+    return { error: MISSING_STRUCTURE };
   if (!participantIds?.length) {
     return { error: MISSING_PARTICIPANT_IDS };
   }
-  const { encounters } = getEncounters({ matchUps: structure.matchUps });
+  const { encounters } = getEncounters({ matchUps: structure?.matchUps ?? [] });
   const valueObjects = {};
   for (const pairing of encounters) {
     if (!valueObjects[pairing])
@@ -44933,7 +45001,7 @@ function generateDrawMaticRound({
   );
   if (teamParticipants) {
     for (const teamParticipant of teamParticipants) {
-      const participantIds2 = teamParticipant.individualParticipantIds || [];
+      const participantIds2 = teamParticipant.individualParticipantIds ?? [];
       const { uniquePairings: uniquePairings2 } = getPairingsData({ participantIds: participantIds2 });
       for (const pairing of uniquePairings2) {
         if (!valueObjects[pairing])
@@ -44964,12 +45032,12 @@ function generateDrawMaticRound({
   let matchUps;
   if (generateMatchUps) {
     const result = generateAdHocMatchUps$1({
+      structureId: structure?.structureId,
       participantIdPairings,
       tournamentRecord,
       addToStructure,
       newRound: true,
       drawDefinition,
-      structureId,
       matchUpIds
     });
     if (result.error)
@@ -45101,6 +45169,7 @@ function drawMatic$1({
   addToStructure,
   participantIds,
   drawDefinition,
+  scaleAccessor,
   maxIterations,
   structureId,
   matchUpIds,
@@ -45148,6 +45217,7 @@ function drawMatic$1({
   const structureIsAdHoc = isAdHoc({ drawDefinition, structure });
   if (!structureIsAdHoc)
     return { error: INVALID_DRAW_DEFINITION };
+  tournamentParticipants = tournamentParticipants ?? tournamentRecord.participants ?? [];
   const adHocRatings = {};
   for (const participantId of participantIds ?? []) {
     const participant = tournamentParticipants?.find(
@@ -45155,7 +45225,12 @@ function drawMatic$1({
     );
     let scaleValue = getScaleValue({ eventType, participant });
     if (!scaleValue && scaleName) {
-      scaleValue = getScaleValue({ scaleName, eventType, participant });
+      scaleValue = getScaleValue({
+        scaleAccessor,
+        participant,
+        scaleName,
+        eventType
+      });
     }
     if (scaleValue)
       adHocRatings[participantId] = scaleValue;
@@ -45169,13 +45244,17 @@ function drawMatic$1({
     drawDefinition,
     maxIterations,
     adHocRatings,
-    structureId,
     matchUpIds,
     structure,
     eventType
   });
 }
-function getScaleValue({ scaleName = "dynamic", eventType, participant }) {
+function getScaleValue({
+  eventType = TypeEnum.Singles,
+  scaleName = "dynamic",
+  scaleAccessor,
+  participant
+}) {
   const scaleAttributes = {
     eventType: eventType || TypeEnum.Singles,
     scaleType: RATING$2,
@@ -45185,7 +45264,8 @@ function getScaleValue({ scaleName = "dynamic", eventType, participant }) {
     scaleAttributes,
     participant
   });
-  return result?.scaleItem?.scaleValue;
+  const scaleValue = result?.scaleItem?.scaleValue;
+  return scaleAccessor && isObject(scaleValue) ? scaleValue[scaleAccessor] : scaleValue;
 }
 
 function setDelegatedOutcome$1({
@@ -47254,7 +47334,7 @@ function getOrderedTieFormat({ tieFormat, orderMap }) {
       collectionDefinition.collectionOrder = collectionOrder;
   });
   orderedTieFormat.collectionDefinitions.sort(
-    (a, b) => a.collectionOrder - b.collectionOrder
+    (a, b) => numericSortValue(a.collectionOrder) - numericSortValue(b.collectionOrder)
   );
   return orderedTieFormat;
 }
@@ -47268,8 +47348,11 @@ function orderCollectionDefinitions({
   matchUp,
   event
 }) {
-  if (typeof orderMap !== "object")
-    return { error: INVALID_VALUES, orderMap };
+  if (typeof orderMap !== "object" || !Object.values(orderMap).every((val) => isConvertableInteger(val)))
+    return decorateResult({
+      result: { error: INVALID_VALUES },
+      context: { orderMap }
+    });
   if (eventId && event?.tieFormat) {
     updateEventTieFormat({ tournamentRecord, event, orderMap });
   } else if (matchUpId) {
@@ -48726,7 +48809,7 @@ function modifyTieFormat({
       processedTieFormat = result2.tieFormat;
   }
   processedTieFormat.collectionDefinitions = processedTieFormat.collectionDefinitions.sort(
-    (a, b) => (a.collectionOrder || Infinity) - (b.collectionOrder || Infinity)
+    (a, b) => numericSortValue(a.collectionOrder) - numericSortValue(b.collectionOrder)
   ).map((def, i) => ({ ...def, collectionOrder: i + 1 }));
   return { ...SUCCESS, processedTieFormat };
 }
@@ -54138,6 +54221,7 @@ function removeTieMatchUpParticipantId(params) {
 function getPositionAssignments({
   tournamentRecord,
   drawDefinition,
+  stage = MAIN,
   structureId,
   structure
 }) {
@@ -54145,6 +54229,11 @@ function getPositionAssignments({
     return { error: MISSING_TOURNAMENT_RECORD };
   if (!structure && !drawDefinition)
     return { error: MISSING_DRAW_DEFINITION };
+  if (!structure && !structureId && drawDefinition?.structures?.filter((structure2) => structure2.stage === stage).length === 1) {
+    structure = drawDefinition.structures.find(
+      (structure2) => structure2.stage === stage
+    );
+  }
   if (!structure && !structureId)
     return { error: MISSING_STRUCTURE_ID };
   const { error, positionAssignments: assignments } = getPositionAssignments$1({
@@ -54152,7 +54241,11 @@ function getPositionAssignments({
     structureId,
     structure
   });
-  return { error, positionAssignments: assignments || [] };
+  return {
+    error,
+    positionAssignments: assignments || [],
+    structureId: structure?.structureId
+  };
 }
 
 function deleteDrawDefinitions({
@@ -57107,7 +57200,7 @@ function prepareStage(params) {
         stage
       }));
     }
-    const scaledEntriesCount = scaledEntries?.length || 0;
+    const scaledEntriesCount = scaledEntries?.length ?? 0;
     if (scaledEntriesCount < seedsCount)
       seedsCount = scaledEntriesCount;
     scaledEntries?.filter(
@@ -57478,12 +57571,28 @@ function generateDrawDefinition(params) {
       const matchUpsCount = entries2 ? Math.floor(entries2.length / 2) : 0;
       generateRange(1, params.roundsCount + 1).forEach(() => {
         if (params.automated) {
+          const {
+            restrictEntryStatus,
+            generateMatchUps,
+            addToStructure,
+            maxIterations,
+            structureId: structureId2,
+            matchUpIds,
+            scaleName
+          } = params.drawMatic ?? {};
           drawMatic$1({
-            generateMatchUps: true,
-            eventType: matchUpType,
             tournamentRecord,
             participantIds,
-            drawDefinition
+            drawDefinition,
+            eventType: params.drawMatic?.eventType ?? matchUpType,
+            generateMatchUps: generateMatchUps ?? true,
+            restrictEntryStatus,
+            addToStructure,
+            maxIterations,
+            structureId: structureId2,
+            matchUpIds,
+            scaleName
+            // custom rating name to seed dynamic ratings
           });
         } else {
           generateAdHocMatchUps$1({
@@ -57609,6 +57718,12 @@ function renameStructures(params) {
   return renameStructures$1(params);
 }
 
+function resetMatchUpLineUps(params) {
+  if (!params.tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  return resetMatchUpLineUps$1(params);
+}
+
 function aggregateTieFormats({
   tournamentRecord
 }) {
@@ -57720,18 +57835,13 @@ function enableTieAutoCalc(params) {
   return enableTieAutoCalc$1(params);
 }
 
-function resetMatchUpLineUps(params) {
-  if (!params.tournamentRecord)
-    return { error: MISSING_TOURNAMENT_RECORD };
-  return resetMatchUpLineUps$1(params);
-}
-
 const eventGovernor = {
   generateQualifyingStructure,
   attachQualifyingStructure,
   attachPlayoffStructures,
-  attachStructures,
   addQualifyingStructure,
+  setStructureOrder,
+  attachStructures,
   renameStructures,
   disableTieAutoCalc,
   enableTieAutoCalc,
@@ -57831,9 +57941,10 @@ const eventGovernor = {
   checkOutParticipant,
   toggleParticipantCheckInState: toggleParticipantCheckInState$1,
   addDrawDefinitionTimeItem,
-  generateDrawDefinition,
-  generateDrawStructuresAndLinks,
   generateDrawTypeAndModifyDrawDefinition,
+  generateDrawStructuresAndLinks,
+  generateDrawMaticRound,
+  generateDrawDefinition,
   applyLineUps,
   assignTieMatchUpParticipantId,
   removeTieMatchUpParticipantId,