tods-competition-factory 1.6.18 → 1.6.20

package/dist/index.mjs

@@ -329,7 +329,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.6.18";
+  return "1.6.20";
 }
 
 function getObjectTieFormat(obj) {
@@ -6195,15 +6195,15 @@ function getRoundMatchUps$1({
       roundIndex += 1;
     }
   });
-  const isNotEliminationStructure = !!Object.values(roundProfile).find(
+  const roundsNotPowerOf2 = !!Object.values(roundProfile).find(
     ({ matchUpsCount }) => !isPowerOf2(matchUpsCount)
   );
   const hasNoRoundPositions = matchUps.some(
     (matchUp) => !matchUp.roundPosition
   );
   return {
-    isNotEliminationStructure,
     hasNoRoundPositions,
+    roundsNotPowerOf2,
     maxMatchUpsCount,
     roundMatchUps,
     roundNumbers,
@@ -7527,31 +7527,29 @@ function filterMatchUps(params) {
 }
 
 function isLucky({
-  isNotEliminationStructure,
+  roundsNotPowerOf2,
   drawDefinition,
-  roundMatchUps,
-  structure
+  structure,
+  matchUps
 }) {
   if (!structure)
     return false;
-  if (!roundMatchUps) {
-    ({ isNotEliminationStructure, roundMatchUps } = getRoundMatchUps$1({
-      matchUps: structure.matchUps ?? []
-    }));
-  }
-  const hasFirstRoundDrawPositions = !!roundMatchUps?.[1]?.find(
-    ({ drawPositions }) => drawPositions
-  );
-  const noSecondRoundDrawPositions = !roundMatchUps?.[2]?.find(
-    ({ drawPositions }) => drawPositions
-  );
-  return isNotEliminationStructure && !structure?.structures && hasFirstRoundDrawPositions && noSecondRoundDrawPositions && !(drawDefinition?.drawType && drawDefinition.drawType !== LUCKY_DRAW);
+  matchUps = matchUps ?? structure.matchUps ?? [];
+  roundsNotPowerOf2 = roundsNotPowerOf2 ?? getRoundMatchUps$1({ matchUps }).roundsNotPowerOf2;
+  const hasDrawPositions = !!structure.positionAssignments?.find(({ drawPosition }) => drawPosition) || !!matchUps?.find(({ drawPositions }) => drawPositions?.length);
+  return (!drawDefinition?.drawType || drawDefinition.drawType !== LUCKY_DRAW) && !structure?.structures && roundsNotPowerOf2 && hasDrawPositions;
 }
 
 function isAdHoc({ drawDefinition, structure }) {
   if (!structure)
     return false;
-  return !structure?.structures && !(drawDefinition?.drawType && drawDefinition.drawType !== AD_HOC) && !structure?.matchUps?.find(({ roundPosition }) => !!roundPosition);
+  const hasRoundPosition = structure?.matchUps?.find(
+    (matchUp) => matchUp?.roundPosition
+  );
+  const hasDrawPosition = structure?.matchUps?.find(
+    (matchUp) => matchUp?.drawPositions?.length
+  );
+  return !structure?.structures && !(drawDefinition?.drawType && drawDefinition.drawType !== AD_HOC) && !hasRoundPosition && !hasDrawPosition;
 }
 
 const POLICY_ROUND_NAMING_DEFAULT = {
@@ -7586,14 +7584,10 @@ function getRoundContextProfile({
   structure,
   matchUps
 }) {
-  const { isNotEliminationStructure, roundProfile, roundMatchUps } = getRoundMatchUps$1({ matchUps });
+  const { roundProfile, roundMatchUps } = getRoundMatchUps$1({ matchUps });
   const { structureAbbreviation, stage } = structure;
   const isAdHocStructure = isAdHoc({ structure });
-  const isLuckyStructure = isLucky({
-    isNotEliminationStructure,
-    roundMatchUps,
-    structure
-  });
+  const isLuckyStructure = isLucky({ structure });
   const isRoundRobin = structure.structures;
   const roundNamingProfile = {};
   const defaultRoundNamingPolicy = POLICY_ROUND_NAMING_DEFAULT[POLICY_TYPE_ROUND_NAMING];
@@ -23020,7 +23014,7 @@ function getValidSeedBlocks({
   let validSeedBlocks = [];
   if (!structure)
     return { error: MISSING_STRUCTURE };
-  const { roundMatchUps } = getAllStructureMatchUps({
+  const { matchUps, roundMatchUps } = getAllStructureMatchUps({
     matchUpFilters: { roundNumbers: [1] },
     provisionalPositioning,
     structure
@@ -23053,12 +23047,16 @@ function getValidSeedBlocks({
   const { stage, structureType, roundLimit } = structure;
   const isContainer = structureType === CONTAINER;
   const isFeedIn = !isContainer && uniqueDrawPositionsByRound?.length;
-  const isLucky = firstRoundDrawPositions?.length && !isPowerOf2(baseDrawSize);
   const qualifyingBlocks = !isContainer && stage === QUALIFYING && roundLimit;
   const fedSeedBlockPositions = seedRangeDrawPositionBlocks.flat(Infinity);
   const fedSeedNumberOffset = isFeedIn ? fedSeedBlockPositions?.length : 0;
   const countLimit = allPositions ? positionsCount : seedsCount;
-  const firstRoundSeedsCount = isLucky ? 0 : !isFeedIn && countLimit || countLimit && fedSeedBlockPositions.length < countLimit && countLimit - fedSeedBlockPositions.length || 0;
+  const isLuckyStructure = isLucky({
+    drawDefinition,
+    structure,
+    matchUps
+  });
+  const firstRoundSeedsCount = isLuckyStructure ? 0 : !isFeedIn && countLimit || countLimit && fedSeedBlockPositions.length < countLimit && countLimit - fedSeedBlockPositions.length || 0;
   if (qualifyingBlocks) {
     const seedingBlocksCount = structure?.matchUps ? structure.matchUps.filter(
       ({ roundNumber }) => roundNumber === structure.roundLimit
@@ -23094,14 +23092,14 @@ function getValidSeedBlocks({
     validSeedBlocks = seedRangeDrawPositionBlocks.map((block) => {
       return { seedNumbers: block, drawPositions: block };
     });
-  } else if (isLucky) {
+  } else if (isLuckyStructure) {
     const blocks = chunkArray(firstRoundDrawPositions, 2).map((block, i) => ({
       drawPositions: [block[0]],
       seedNumbers: [i + 1]
     }));
     blocks.forEach((block) => validSeedBlocks.push(block));
   }
-  if (!isContainer && !isLucky && !qualifyingBlocks) {
+  if (!isContainer && !isLuckyStructure && !qualifyingBlocks) {
     const { blocks } = constructPower2Blocks({
       drawPositionOffset: firstRoundDrawPositionOffset,
       seedNumberOffset: fedSeedNumberOffset,
@@ -23120,7 +23118,7 @@ function getValidSeedBlocks({
     },
     true
   );
-  if (!isLucky && !isFeedIn && !isContainer && !validSeedPositions) {
+  if (!isLuckyStructure && !isFeedIn && !isContainer && !validSeedPositions) {
     return {
       error: INVALID_SEED_POSITION,
       validSeedBlocks: [],
@@ -23129,10 +23127,10 @@ function getValidSeedBlocks({
     };
   }
   return {
+    isLuckyStructure,
     validSeedBlocks,
     isContainer,
-    isFeedIn,
-    isLucky
+    isFeedIn
   };
 }
 function getContainerBlocks({ seedingProfile, structure }) {
@@ -23475,6 +23473,75 @@ function getTargetMatchUps({
   return { drawPositions, matchUps, targetMatchUps };
 }
 
+function validateLineUp({ lineUp, tieFormat }) {
+  const errors = [];
+  if (!Array.isArray(lineUp)) {
+    errors.push(mustBeAnArray("lineUp"));
+    return { valid: false, errors, error: INVALID_VALUES };
+  }
+  const validItems = lineUp.every((item) => {
+    if (typeof item !== "object") {
+      errors.push(`lineUp entries must be objects`);
+      return false;
+    }
+    const { participantId, collectionAssignments } = item;
+    if (!participantId) {
+      errors.push("Missing participantId");
+      return false;
+    }
+    if (typeof participantId !== "string") {
+      errors.push("participantIds must be strings");
+      return false;
+    }
+    if (!Array.isArray(collectionAssignments)) {
+      errors.push(mustBeAnArray("collectionAssignments"));
+      return false;
+    }
+    return collectionAssignments.every((collectionAssignment) => {
+      if (typeof collectionAssignment !== "object") {
+        errors.push("collectionAssignments must be objects");
+        return false;
+      }
+      const { collectionPosition } = collectionAssignment;
+      if (typeof collectionPosition !== "number") {
+        errors.push("collectionPosition must be a number");
+        return false;
+      }
+      return true;
+    });
+  });
+  const noDuplicates = unique(lineUp.map(getParticipantId)).length === lineUp.length;
+  if (!noDuplicates)
+    errors.push("Duplicated participantId(s)");
+  const valid = validItems && noDuplicates;
+  return { valid, errors, error: errors.length ? INVALID_VALUES : void 0 };
+}
+
+function updateTeamLineUp({
+  drawDefinition,
+  participantId,
+  tieFormat,
+  lineUp
+}) {
+  if (typeof drawDefinition !== "object")
+    return { error: MISSING_DRAW_DEFINITION };
+  if (typeof participantId !== "string")
+    return { error: MISSING_PARTICIPANT_ID };
+  const validation = validateLineUp({ lineUp, tieFormat });
+  if (!validation.valid)
+    return validation;
+  const { extension: existingExtension } = findExtension({
+    element: drawDefinition,
+    name: LINEUPS
+  });
+  const value = existingExtension?.value || {};
+  value[participantId] = removeLineUpSubstitutions({ lineUp });
+  const extension = { name: LINEUPS, value };
+  addExtension$1({ element: drawDefinition, extension });
+  addDrawNotice({ drawDefinition });
+  return { ...SUCCESS };
+}
+
 function resetLineUps({
   inContextDrawMatchUps,
   inheritance = true,
@@ -23502,10 +23569,18 @@ function resetLineUps({
           ({ matchUpId }) => matchUpId === inContextMatchUp.matchUpId
         );
         if (matchUp?.sides?.[sideIndex]) {
-          if (inheritance) {
-            delete matchUp.sides[sideIndex].lineUp;
-          } else {
-            matchUp.sides[sideIndex].lineUp = [];
+          delete matchUp.sides[sideIndex].lineUp;
+          if (inheritance === false) {
+            const tieFormat = inContextMatchUp.tieFormat;
+            const participantId = side.participantId;
+            if (tieFormat && participantId) {
+              updateTeamLineUp({
+                drawDefinition,
+                participantId,
+                lineUp: [],
+                tieFormat
+              });
+            }
           }
           modifyMatchUpNotice({
             tournamentId: tournamentRecord?.tournamentId,
@@ -40274,7 +40349,7 @@ function getSeedOrderByePositions({
       structure
     });
   }
-  const { isFeedIn, isLucky, isContainer } = seedBlockInfo;
+  const { isFeedIn, isLuckyStructure, isContainer } = seedBlockInfo;
   let { validSeedBlocks } = seedBlockInfo;
   if (appliedPolicies?.seeding?.containerByesIgnoreSeeding)
     validSeedBlocks = [];
@@ -40318,10 +40393,10 @@ function getSeedOrderByePositions({
   return {
     strictSeedOrderByePositions,
     blockSeedOrderByePositions,
+    isLuckyStructure,
     positionedSeeds,
     isContainer,
-    isFeedIn,
-    isLucky
+    isFeedIn
   };
 }
 function getOrderedByePositions({
@@ -40348,12 +40423,12 @@ function getOrderedByePositions({
 function getUnseededByePositions({
   provisionalPositioning,
   seedOrderByePositions,
+  isLuckyStructure,
   appliedPolicies,
   drawDefinition,
   seedLimit,
   structure,
-  isFeedIn,
-  isLucky
+  isFeedIn
 }) {
   const seedingProfile = appliedPolicies?.seeding?.seedingProfile;
   const isQualifying = structure.stage === QUALIFYING;
@@ -40571,8 +40646,8 @@ function positionByes({
   const {
     strictSeedOrderByePositions,
     blockSeedOrderByePositions,
-    isFeedIn,
-    isLucky
+    isLuckyStructure,
+    isFeedIn
   } = getSeedOrderByePositions({
     provisionalPositioning,
     relevantMatchUps,
@@ -40587,12 +40662,12 @@ function positionByes({
   let { unseededByePositions } = getUnseededByePositions({
     provisionalPositioning,
     seedOrderByePositions,
+    isLuckyStructure,
     appliedPolicies,
     drawDefinition,
     seedLimit,
     structure,
-    isFeedIn,
-    isLucky
+    isFeedIn
   });
   const isOdd = (x) => x % 2;
   const isNotPaired = (arr, c) => (arr || []).every((a) => isOdd(a) ? c !== a + 1 : c !== a - 1);
@@ -44598,28 +44673,40 @@ function roundRobinSwap({
 }
 
 function resetMatchUpLineUps$1({
+  inheritance = true,
   tournamentRecord,
   drawDefinition,
-  inheritance,
   matchUpId,
   event
 }) {
   if (!drawDefinition)
     return { error: MISSING_DRAW_DEFINITION };
   const matchUp = findMatchUp$1({
-    inContext: true,
     drawDefinition,
     matchUpId
   })?.matchUp;
-  if (matchUp?.matchUpType !== TEAM_MATCHUP)
+  if (!matchUp?.tieMatchUps)
     return { error: INVALID_MATCHUP };
   let modificationsCount = 0;
   (matchUp.sides || []).forEach((side) => {
     modificationsCount += 1;
-    if (inheritance) {
-      delete side.lineUp;
-    } else {
-      side.lineUp = [];
+    delete side.lineUp;
+    if (inheritance === false) {
+      const inContextMatchUp = findMatchUp$1({
+        inContext: true,
+        drawDefinition,
+        matchUpId
+      })?.matchUp;
+      const tieFormat = inContextMatchUp?.tieFormat;
+      const participantId = side.participantId;
+      if (tieFormat && participantId) {
+        updateTeamLineUp({
+          drawDefinition,
+          participantId,
+          lineUp: [],
+          tieFormat
+        });
+      }
     }
     modifyMatchUpNotice({
       tournamentId: tournamentRecord?.tournamentId,
@@ -51369,75 +51456,6 @@ function removeCollectionAssignments({
   return { modifiedLineUp, assignmentsRemoved, previousParticipantIds };
 }
 
-function validateLineUp({ lineUp, tieFormat }) {
-  const errors = [];
-  if (!Array.isArray(lineUp)) {
-    errors.push(mustBeAnArray("lineUp"));
-    return { valid: false, errors, error: INVALID_VALUES };
-  }
-  const validItems = lineUp.every((item) => {
-    if (typeof item !== "object") {
-      errors.push(`lineUp entries must be objects`);
-      return false;
-    }
-    const { participantId, collectionAssignments } = item;
-    if (!participantId) {
-      errors.push("Missing participantId");
-      return false;
-    }
-    if (typeof participantId !== "string") {
-      errors.push("participantIds must be strings");
-      return false;
-    }
-    if (!Array.isArray(collectionAssignments)) {
-      errors.push(mustBeAnArray("collectionAssignments"));
-      return false;
-    }
-    return collectionAssignments.every((collectionAssignment) => {
-      if (typeof collectionAssignment !== "object") {
-        errors.push("collectionAssignments must be objects");
-        return false;
-      }
-      const { collectionPosition } = collectionAssignment;
-      if (typeof collectionPosition !== "number") {
-        errors.push("collectionPosition must be a number");
-        return false;
-      }
-      return true;
-    });
-  });
-  const noDuplicates = unique(lineUp.map(getParticipantId)).length === lineUp.length;
-  if (!noDuplicates)
-    errors.push("Duplicated participantId(s)");
-  const valid = validItems && noDuplicates;
-  return { valid, errors, error: errors.length ? INVALID_VALUES : void 0 };
-}
-
-function updateTeamLineUp({
-  drawDefinition,
-  participantId,
-  tieFormat,
-  lineUp
-}) {
-  if (typeof drawDefinition !== "object")
-    return { error: MISSING_DRAW_DEFINITION };
-  if (typeof participantId !== "string")
-    return { error: MISSING_PARTICIPANT_ID };
-  const validation = validateLineUp({ lineUp, tieFormat });
-  if (!validation.valid)
-    return validation;
-  const { extension: existingExtension } = findExtension({
-    element: drawDefinition,
-    name: LINEUPS
-  });
-  const value = existingExtension?.value || {};
-  value[participantId] = removeLineUpSubstitutions({ lineUp });
-  const extension = { name: LINEUPS, value };
-  addExtension$1({ element: drawDefinition, extension });
-  addDrawNotice({ drawDefinition });
-  return { ...SUCCESS };
-}
-
 function getTieMatchUpContext({
   tournamentRecord,
   drawDefinition,