tods-competition-factory 1.6.22 → 1.6.23

package/dist/index.mjs

@@ -329,7 +329,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.6.22";
+  return "1.6.23";
 }
 
 function getObjectTieFormat(obj) {
@@ -9144,25 +9144,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
   };
 }
 
@@ -41522,6 +41522,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 +42170,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,
@@ -44918,10 +44948,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])
@@ -44964,12 +45003,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 +45140,7 @@ function drawMatic$1({
   addToStructure,
   participantIds,
   drawDefinition,
+  scaleAccessor,
   maxIterations,
   structureId,
   matchUpIds,
@@ -45148,6 +45188,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 +45196,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 +45215,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 +45235,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({
@@ -57478,12 +57529,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({
@@ -57831,9 +57898,10 @@ const eventGovernor = {
   checkOutParticipant,
   toggleParticipantCheckInState: toggleParticipantCheckInState$1,
   addDrawDefinitionTimeItem,
-  generateDrawDefinition,
-  generateDrawStructuresAndLinks,
   generateDrawTypeAndModifyDrawDefinition,
+  generateDrawStructuresAndLinks,
+  generateDrawMaticRound,
+  generateDrawDefinition,
   applyLineUps,
   assignTieMatchUpParticipantId,
   removeTieMatchUpParticipantId,