tods-competition-factory 1.8.23 → 1.8.25

package/dist/index.mjs

@@ -1021,6 +1021,10 @@ const SCHEDULED_MATCHUPS = {
   message: "Scheduled matchUps",
   code: "ERR_SCHEDULED_MATCHUPS"
 };
+const SCORES_PRESENT = {
+  message: "Scores present",
+  code: "ERR_SCORES_PRESENT"
+};
 const errorConditionConstants = {
   ANACHRONISM,
   CANNOT_CHANGE_WINNING_SIDE,
@@ -1183,6 +1187,7 @@ const errorConditionConstants = {
   POLICY_NOT_FOUND,
   SCHEDULE_NOT_CLEARED,
   SCHEDULED_MATCHUPS,
+  SCORES_PRESENT,
   SEEDSCOUNT_GREATER_THAN_DRAW_SIZE,
   STAGE_SEQUENCE_LIMIT,
   STRUCTURE_NOT_FOUND,
@@ -2382,7 +2387,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.8.23";
+  return "1.8.25";
 }
 
 function getObjectTieFormat(obj) {
@@ -3811,18 +3816,17 @@ function getTallyReport({ matchUps, order, report }) {
         readable.push(excluded);
       } else {
         const floatSort = (a, b) => parseFloat(step.reversed ? a : b) - parseFloat(step.reversed ? b : a);
+        const participantsCount = step.groups ? Object.values(step.groups).flat(Infinity).length : step.participantIds?.length ?? 0;
         const getExplanation = (step2) => {
-          Object.keys(step2.groups).sort(floatSort).forEach((key) => {
+          step2.groups && Object.keys(step2.groups).sort(floatSort).forEach((key) => {
             const participantNames = step2.groups[key].map((participantId) => participants[participantId]).join(", ");
             const explanation = `${key} ${step2.attribute}: ${participantNames}`;
             readable.push(explanation);
           });
         };
         const reversed = step.reversed ? " in reverse order" : "";
-        const participantsCount = Object.values(step.groups).flat(
-          Infinity
-        ).length;
-        const description = `Step ${i + 1}: ${participantsCount} particiants were grouped${reversed} by ${step.attribute}`;
+        const action = step.groups ? "grouped" : "separated";
+        const description = `Step ${i + 1}: ${participantsCount} particiants were ${action}${reversed} by ${step.attribute}`;
         readable.push(description);
         if (step.idsFilter) {
           const note = `${step.attribute} was calculated considering ONLY TIED PARTICIPANTS`;
@@ -3838,7 +3842,7 @@ function getTallyReport({ matchUps, order, report }) {
     const { participantId, resolved } = orderEntry;
     const pOrder = orderEntry.groupOrder || orderEntry.provisionalOrder;
     readable.push(
-      `${pOrder}: ${participants[participantId]} => resolved: ${resolved}`
+      `${pOrder}: ${participants[participantId]} => resolved: ${!!resolved}`
     );
   });
   return readable.join("\r\n");
@@ -3927,7 +3931,7 @@ function getGroupOrder(params) {
   report.push({ attribute, groups: orderedTallyGroups });
   const groupOrder = Object.keys(orderedTallyGroups).map((key) => parseFloat(key)).sort((a, b) => b - a).map((key) => orderedTallyGroups[key]).map((participantIds) => {
     const result = groupSubSort({ participantIds, ...params });
-    report.push(result.report);
+    report.push(...result.report || []);
     return result.order;
   }).flat(Infinity);
   let groupPosition = 1;
@@ -4019,7 +4023,7 @@ function processAttribute({
         tallyPolicy,
         matchUps
       });
-      report.push(result.report);
+      report.push(...result.report || []);
       return result.order;
     }).flat(Infinity);
   }
@@ -4033,6 +4037,9 @@ function groupSubSort({
   tallyPolicy,
   matchUps
 }) {
+  const excludedDirectives = [];
+  const report = [];
+  let result;
   if (participantIds?.length === 1) {
     const participantId = participantIds[0];
     return {
@@ -4041,13 +4048,13 @@ function groupSubSort({
   }
   if (participantIds?.length === 2 && (!tallyPolicy?.headToHead || !tallyPolicy.headToHead.disabled && !disableHeadToHead)) {
     const result2 = headToHeadWinner({ participantIds, participantResults });
-    if (result2)
-      return { order: [result2], headToHeadWinner: result2[0].participantId };
+    if (result2) {
+      const headToHeadWinner2 = result2[0].participantId;
+      report.push({ attribute: "head2Head", participantIds, headToHeadWinner: headToHeadWinner2 });
+      return { order: [result2], headToHeadWinner: headToHeadWinner2, report };
+    }
   }
   const directives = tallyPolicy?.tallyDirectives || headToHeadTallyDirectives;
-  const excludedDirectives = [];
-  const report = [];
-  let result;
   const filteredDirectives = directives.filter((directive) => {
     const keepDirective = isNumeric(directive.maxParticipants) && participantIds?.length > directive.maxParticipants ? false : true;
     if (!keepDirective)
@@ -7775,7 +7782,8 @@ const POLICY_ROUND_NAMING_DEFAULT = {
   [POLICY_TYPE_ROUND_NAMING]: {
     policyName: "Round Naming Default",
     namingConventions: {
-      round: "Round"
+      round: "Round",
+      pre: "Pre"
     },
     qualifyingFinishMap: {
       1: "Final"
@@ -7819,12 +7827,11 @@ function getRoundContextProfile({
   const roundNamingProfile = {};
   const defaultRoundNamingPolicy = POLICY_ROUND_NAMING_DEFAULT[POLICY_TYPE_ROUND_NAMING];
   const isQualifying = structure.stage === QUALIFYING;
-  const qualifyingFinishgMap = isQualifying && (roundNamingPolicy?.qualifyingFinishMap || defaultRoundNamingPolicy?.qualifyingFinishMap || {});
   const qualifyingStageSequences = isQualifying ? Math.max(
     ...(drawDefinition?.structures ?? []).filter((structure2) => structure2.stage === QUALIFYING).map(({ stageSequence }) => stageSequence ?? 1),
     0
   ) : 0;
-  const preQualifyingSequence = qualifyingStageSequences ? qualifyingStageSequences - (structure.stageSequence ?? 1) || "" : "";
+  const preQualifyingSequence = (structure.stageSequence ?? 1) < qualifyingStageSequences ? structure.stageSequence ?? 1 : "";
   const preQualifyingAffix = preQualifyingSequence ? roundNamingPolicy?.affixes?.preQualifying || defaultRoundNamingPolicy.affixes.preQualifying || "" : "";
   const roundNamingMap = roundNamingPolicy?.roundNamingMap || defaultRoundNamingPolicy.roundNamingMap || {};
   const abbreviatedRoundNamingMap = roundNamingPolicy?.abbreviatedRoundNamingMap || defaultRoundNamingPolicy.abbreviatedRoundNamingMap || {};
@@ -7848,6 +7855,7 @@ function getRoundContextProfile({
       })
     );
   } else {
+    const qualifyingFinishgMap = isQualifying && (roundNamingPolicy?.qualifyingFinishMap || defaultRoundNamingPolicy?.qualifyingFinishMap || {});
     Object.assign(
       roundNamingProfile,
       ...roundProfileKeys.map((round) => {
@@ -10122,8 +10130,10 @@ function modifyMatchUpScore({
         const matchUpFilters = isDualMatchUp ? { matchUpTypes: [TEAM$2] } : void 0;
         const { matchUps } = getAllStructureMatchUps({
           afterRecoveryTimes: false,
+          tournamentRecord,
           inContext: true,
           matchUpFilters,
+          drawDefinition,
           structure: structure2,
           event
         });
@@ -23088,7 +23098,10 @@ function getAffectedTargetStructureIds({
   return { structureIds };
 }
 
-function getPlayoffStructures({ drawDefinition, structureId }) {
+function getPlayoffStructures({
+  drawDefinition,
+  structureId
+}) {
   if (!drawDefinition)
     return { error: MISSING_DRAW_DEFINITION };
   const { structure } = findStructure({ drawDefinition, structureId });
@@ -23223,7 +23236,7 @@ function allPlayoffPositionsFilled(params) {
           return assignment?.bye || assignment?.participantId;
         }
       ).length;
-      return structurePositionsFilled && allFilled;
+      return !!(structurePositionsFilled && allFilled);
     },
     !!playoffStructures.length
   );
@@ -43393,6 +43406,142 @@ function generateVoluntaryConsolation$1(params) {
   return { links, structures, ...SUCCESS };
 }
 
+function getStructureGroups({
+  drawDefinition
+}) {
+  const structures = drawDefinition.structures || [];
+  const links = drawDefinition.links || [];
+  const structureProfiles = /* @__PURE__ */ new Map();
+  const initStructureProfile = (structureId) => {
+    const profile = structureProfiles.get(structureId) || structureProfiles.set(structureId, {
+      drawSources: [],
+      drawTargets: [],
+      progeny: [],
+      sources: [],
+      targets: []
+    }) && structureProfiles.get(structureId);
+    if (profile && !profile?.stage) {
+      const structure = structures.find(
+        (structure2) => structure2.structureId === structureId
+      );
+      profile.stage = structure?.stage;
+    }
+    return profile;
+  };
+  const sourceStructureIds = {};
+  const hasDrawFeedProfile = {};
+  let linkedStructureIds = links.map((link) => {
+    const sourceId = link.source.structureId;
+    const targetId = link.target.structureId;
+    const sourceProfile = initStructureProfile(sourceId);
+    const targetProfile = initStructureProfile(targetId);
+    if ([BOTTOM_UP, TOP_DOWN, RANDOM, WATERFALL].includes(link.target.feedProfile)) {
+      sourceProfile?.targets.push(targetId);
+      targetProfile?.sources.push(sourceId);
+    } else if (link.target.feedProfile === DRAW) {
+      targetProfile?.drawSources.push(sourceId);
+      sourceProfile?.drawTargets.push(targetId);
+    }
+    hasDrawFeedProfile[targetId] = hasDrawFeedProfile[targetId] || link.target.feedProfile === DRAW;
+    sourceStructureIds[targetId] = unique([
+      ...sourceStructureIds[targetId] || [],
+      sourceId
+    ]).filter(Boolean);
+    return [link.source.structureId, link.target.structureId];
+  });
+  for (const structureId of structureProfiles.keys()) {
+    const profile = structureProfiles.get(structureId);
+    if (profile) {
+      const sourceIds = profile.targets ?? [];
+      while (sourceIds.length) {
+        const sourceId = sourceIds.pop();
+        const sourceProfile = sourceId && structureProfiles[sourceId];
+        if (sourceProfile?.targets?.length) {
+          sourceIds.push(...sourceProfile.targets);
+        } else if (sourceProfile) {
+          profile.rootStage = sourceProfile.stage;
+        }
+      }
+      if (!profile.rootStage)
+        profile.rootStage = profile.stage;
+      if (!profile.targets?.length) {
+        const targetIds = profile.sources ?? [];
+        while (targetIds.length) {
+          const targetId = targetIds.pop();
+          const targetProfile = targetId && structureProfiles[targetId];
+          if (targetProfile?.sources?.length) {
+            for (const id of targetProfile.sources) {
+              if (!profile.progeny?.includes(id))
+                profile.progeny?.push(id);
+            }
+            targetIds.push(...targetProfile.sources);
+          }
+        }
+      }
+    }
+  }
+  let maxQualifyingDepth = 0;
+  for (const structureId of structureProfiles.keys()) {
+    const profile = structureProfiles.get(structureId);
+    if (profile && profile.rootStage === QUALIFYING) {
+      const drawTargets = [profile.drawTargets?.[0]];
+      let distanceFromMain = 0;
+      while (drawTargets.length) {
+        distanceFromMain += 1;
+        const drawTarget = drawTargets.pop();
+        const targetProfile = drawTarget ? structureProfiles.get(drawTarget) : void 0;
+        if (targetProfile?.drawTargets?.length) {
+          drawTargets.push(targetProfile.drawTargets[0]);
+        }
+      }
+      profile.distanceFromMain = distanceFromMain;
+      if (distanceFromMain > maxQualifyingDepth)
+        maxQualifyingDepth = distanceFromMain;
+    }
+  }
+  const iterations = linkedStructureIds.length;
+  generateRange(0, Math.ceil(iterations / 2)).forEach(() => {
+    linkedStructureIds = generateRange(0, iterations).map((index) => {
+      const structureIds = linkedStructureIds[index];
+      const mergedWithOverlappingIds = linkedStructureIds.reduce((biggest, ids) => {
+        const hasOverlap = overlap(structureIds, ids);
+        return hasOverlap ? biggest.concat(...ids) : biggest;
+      }, []) || [];
+      return unique(structureIds.concat(...mergedWithOverlappingIds));
+    });
+  });
+  const groupedStructureIds = linkedStructureIds[0];
+  const identityLink = (a, b) => intersection(a, b).length === a.length;
+  const allLinkStructuresLinked = linkedStructureIds.slice(1).reduce((allLinkStructuresLinked2, ids) => {
+    return allLinkStructuresLinked2 && identityLink(ids, groupedStructureIds);
+  }, true);
+  const structureGroups = [groupedStructureIds].filter(Boolean);
+  const linkCheck = [groupedStructureIds].filter(Boolean);
+  structures.forEach((structure) => {
+    const { structureId, stage } = structure;
+    const existingGroup = structureGroups.find((group) => {
+      return group.includes(structureId);
+    });
+    if (!existingGroup) {
+      structureGroups.push([structureId]);
+      if (stage !== VOLUNTARY_CONSOLATION)
+        linkCheck.push([structureId]);
+    }
+  });
+  const allStructuresLinked = allLinkStructuresLinked && linkCheck.length === 1;
+  if (!links?.length && structures.length === 1) {
+    initStructureProfile(structures[0].structureId);
+  }
+  return {
+    structureProfiles: Object.fromEntries(structureProfiles),
+    allStructuresLinked,
+    maxQualifyingDepth,
+    sourceStructureIds,
+    hasDrawFeedProfile,
+    structureGroups
+  };
+}
+
 function generateQualifyingStructure$1(params) {
   if (!params.drawDefinition)
     return { error: MISSING_DRAW_DEFINITION };
@@ -43417,65 +43566,25 @@ function generateQualifyingStructure$1(params) {
   let roundLimit, roundsCount, structure, matchUps;
   let qualifiersCount = 0;
   let finishingPositions;
-  let stageSequence = 1;
+  const stageSequence = 1;
   if (!isConvertableInteger(drawSize)) {
     return decorateResult({ result: { error: MISSING_DRAW_SIZE }, stack });
   }
-  const result = findStructure({
-    structureId: targetStructureId,
-    drawDefinition
-  });
-  if (result.error) {
+  const { structureProfiles } = getStructureGroups({ drawDefinition });
+  const structureProfile = structureProfiles[targetStructureId];
+  if (!structureProfile) {
     return decorateResult({
+      result: { error: STRUCTURE_NOT_FOUND },
       context: { targetStructureId },
-      result,
       stack
     });
   }
-  if (!result.structure)
-    return { error: STRUCTURE_NOT_FOUND };
-  const targetStructure = result.structure;
-  const matchUpType = targetStructure.matchUpType;
-  if (targetStructure.stage === QUALIFYING) {
-    if (targetStructure.stageSequence && targetStructure.stageSequence > 1) {
-      stageSequence = targetStructure.stageSequence - 1;
-    } else {
-      let nextStructureId = targetStructureId;
-      let nextStageSequence = 2;
-      let chainModified;
-      while (!chainModified && nextStructureId) {
-        console.log("check getRoundContextProfile preqQualifyingStageSequence");
-        targetStructure.stageSequence = nextStageSequence;
-        const targetTargetStructureId = drawDefinition.links?.find(
-          (link2) => link2.source.structureId === nextStructureId
-        )?.target?.structureId;
-        nextStructureId = targetTargetStructureId;
-        nextStageSequence += 1;
-        if (!targetTargetStructureId) {
-          chainModified = true;
-        } else {
-          const result2 = findStructure({
-            structureId: targetTargetStructureId,
-            drawDefinition
-          });
-          if (!result2.structure)
-            return { error: STRUCTURE_NOT_FOUND };
-          if (result2.error) {
-            return decorateResult({
-              context: { targetTargetStructureId },
-              result: result2,
-              stack
-            });
-          }
-          if (result2.structure.stage !== QUALIFYING)
-            chainModified = true;
-        }
-      }
-    }
-  }
+  const matchUpType = drawDefinition.matchUpType;
   const roundTargetName = roundTarget ? `${roundTarget}-` : "";
-  const stageSequenceName = `${stageSequence}`;
-  const qualifyingStructureName = structureName ?? (roundTargetName || stageSequenceName ? `${constantToString(QUALIFYING)} ${roundTargetName}${stageSequenceName}` : constantToString(QUALIFYING));
+  const isPreQualifying = structureProfile.stage === QUALIFYING;
+  const preQualifyingNaming = appliedPolicies?.[POLICY_TYPE_ROUND_NAMING]?.namingConventions?.pre ?? POLICY_ROUND_NAMING_DEFAULT[POLICY_TYPE_ROUND_NAMING]?.namingConventions?.pre;
+  const pre = isPreQualifying && preQualifyingNaming ? `${preQualifyingNaming}-` : "";
+  const qualifyingStructureName = structureName ?? (roundTargetName ? `${pre}${constantToString(QUALIFYING)} ${roundTargetName}` : `${pre}${constantToString(QUALIFYING)}`);
   if (drawType === ROUND_ROBIN) {
     const { maxRoundNumber, structures, groupCount } = generateRoundRobin({
       structureName: structureName ?? qualifyingStructureName,
@@ -43530,13 +43639,13 @@ function generateQualifyingStructure$1(params) {
     )?.length;
   }
   const linkType = drawType === ROUND_ROBIN ? LinkTypeEnum.Position : LinkTypeEnum.Winner;
-  const { link } = generateQualifyingLink({
+  const link = structure && roundLimit && generateQualifyingLink({
     sourceStructureId: structure.structureId,
     sourceRoundNumber: roundLimit,
     targetStructureId,
     finishingPositions,
     linkType
-  });
+  })?.link;
   return {
     qualifyingDrawPositionsCount: drawSize,
     qualifiersCount,
@@ -43546,6 +43655,19 @@ function generateQualifyingStructure$1(params) {
   };
 }
 
+function resequenceStructures({ drawDefinition }) {
+  const { maxQualifyingDepth, structureProfiles } = getStructureGroups({
+    drawDefinition
+  });
+  for (const structure of drawDefinition.structures) {
+    const profile = structureProfiles[structure.structureId];
+    if (profile.distanceFromMain) {
+      structure.stageSequence = maxQualifyingDepth + 1 - profile.distanceFromMain;
+    }
+  }
+  return { ...SUCCESS };
+}
+
 function attachQualifyingStructure$1({
   drawDefinition,
   tournamentId,
@@ -43576,6 +43698,7 @@ function attachQualifyingStructure$1({
     drawDefinition.links = [];
   drawDefinition.structures.push(structure);
   drawDefinition.links.push(link);
+  resequenceStructures({ drawDefinition });
   const matchUps = getAllStructureMatchUps({ structure })?.matchUps || [];
   addMatchUpsNotice({
     drawDefinition,
@@ -43799,6 +43922,10 @@ function getAdvancingParticipantId(matchUp) {
 }
 
 function addQualifyingStructure$1(params) {
+  if (!params.drawDefinition)
+    return { error: MISSING_DRAW_DEFINITION };
+  if (!params.targetStructureId)
+    return { error: MISSING_STRUCTURE_ID };
   const result = generateQualifyingStructure$1(params);
   if (result.error)
     return result;
@@ -44082,7 +44209,8 @@ function removeStructure({
   tournamentRecord,
   drawDefinition,
   structureId,
-  event
+  event,
+  force
 }) {
   if (typeof structureId !== "string")
     return { error: INVALID_VALUES };
@@ -44092,10 +44220,21 @@ function removeStructure({
     return { error: MISSING_STRUCTURE_ID };
   const structures = drawDefinition.structures || [];
   const removedStructureIds = [];
+  const structure = structures.find(
+    (structure2) => structure2.structureId === structureId
+  );
+  if (!structure)
+    return { error: STRUCTURE_NOT_FOUND };
+  const structureMatchUps = getAllStructureMatchUps({ structure }).matchUps;
+  const scoresPresent = structureMatchUps.some(
+    ({ score }) => scoreHasValue({ score })
+  );
+  if (scoresPresent && !force)
+    return { error: SCORES_PRESENT };
   const mainStageSequence1 = structures.find(
     ({ stage, stageSequence }) => stage === MAIN && stageSequence === 1
   );
-  const isMainStageSequence1 = structureId === mainStageSequence1.structureId;
+  const isMainStageSequence1 = structureId === mainStageSequence1?.structureId;
   const qualifyingStructureIds = structures.filter(({ stage }) => stage === QUALIFYING).map(extractAttributes("structureId"));
   if (isMainStageSequence1 && !qualifyingStructureIds.length) {
     return { error: CANNOT_REMOVE_MAIN_STRUCTURE };
@@ -44104,11 +44243,11 @@ function removeStructure({
   const removedMatchUpIds = [];
   const idsToRemove = [structureId];
   const getTargetedStructureIds = (structureId2) => drawDefinition.links?.map(
-    (link) => link.source.structureId === structureId2 && link.target.structureId !== mainStageSequence1.structureId && link.target.structureId
-  ).filter(Boolean);
+    (link) => link.source.structureId === structureId2 && link.target.structureId !== mainStageSequence1?.structureId && link.target.structureId
+  ).filter(Boolean) ?? [];
   const getQualifyingSourceStructureIds = (structureId2) => drawDefinition.links?.map(
     (link) => qualifyingStructureIds.includes(link.source.structureId) && link.target.structureId === structureId2 && link.source.structureId
-  ).filter(Boolean);
+  ).filter(Boolean) ?? [];
   const isQualifyingStructure = qualifyingStructureIds.includes(structureId);
   const relatedStructureIdsMap = /* @__PURE__ */ new Map();
   structureIds.forEach(
@@ -44119,11 +44258,11 @@ function removeStructure({
   );
   while (idsToRemove.length) {
     const idBeingRemoved = idsToRemove.pop();
-    const { structure } = findStructure({
+    const { structure: structure2 } = findStructure({
       structureId: idBeingRemoved,
       drawDefinition
     });
-    const { matchUps: matchUps2 } = getAllStructureMatchUps({ structure });
+    const { matchUps: matchUps2 } = getAllStructureMatchUps({ structure: structure2 });
     const matchUpIds = getMatchUpIds(matchUps2);
     removedMatchUpIds.push(...matchUpIds);
     drawDefinition.links = drawDefinition.links?.filter(
@@ -44131,10 +44270,10 @@ function removeStructure({
     ) || [];
     if (!isMainStageSequence1 || idBeingRemoved !== structureId) {
       drawDefinition.structures = (drawDefinition.structures ?? []).filter(
-        (structure2) => {
-          if (idBeingRemoved && idBeingRemoved === structure2.structureId)
+        (structure3) => {
+          if (idBeingRemoved && idBeingRemoved === structure3.structureId)
             removedStructureIds.push(idBeingRemoved);
-          return structure2.structureId !== idBeingRemoved;
+          return structure3.structureId !== idBeingRemoved;
         }
       );
     }
@@ -44142,7 +44281,7 @@ function removeStructure({
     relatedStructureIdsMap.get(idBeingRemoved)?.filter(
       (id) => (
         // IMPORTANT: only delete MAIN stageSequence: 1 if specified to protect against DOUBLE_ELIMINATION scenario
-        id !== mainStageSequence1.structureId || structureId === mainStageSequence1.structureId
+        id !== mainStageSequence1?.structureId || structureId === mainStageSequence1.structureId
       )
     );
     if (targetedStructureIds?.length)
@@ -44165,6 +44304,7 @@ function removeStructure({
       mainStageSequence1.extensions = [];
     }
   }
+  isQualifyingStructure && resequenceStructures({ drawDefinition });
   deleteMatchUpsNotice({
     tournamentId: tournamentRecord?.tournamentId,
     matchUpIds: removedMatchUpIds,
@@ -52351,59 +52491,6 @@ function unPublishEvent({
   return { eventId: event.eventId, ...SUCCESS };
 }
 
-function getStructureGroups({ drawDefinition }) {
-  const links = drawDefinition.links || [];
-  const sourceStructureIds = {};
-  const hasDrawFeedProfile = {};
-  let linkedStructureIds = links.map((link) => {
-    const sourceId = link.source.structureId;
-    const targetId = link.target.structureId;
-    hasDrawFeedProfile[targetId] = hasDrawFeedProfile[targetId] || link.target.feedProfile === DRAW;
-    sourceStructureIds[targetId] = unique([
-      ...sourceStructureIds[targetId] || [],
-      sourceId
-    ]).filter(Boolean);
-    return [link.source.structureId, link.target.structureId];
-  });
-  const iterations = linkedStructureIds.length;
-  generateRange(0, Math.ceil(iterations / 2)).forEach(() => {
-    linkedStructureIds = generateRange(0, iterations).map((index) => {
-      const structureIds = linkedStructureIds[index];
-      const mergedWithOverlappingIds = linkedStructureIds.reduce((biggest, ids) => {
-        const hasOverlap = overlap(structureIds, ids);
-        return hasOverlap ? biggest.concat(...ids) : biggest;
-      }, []) || [];
-      return unique(structureIds.concat(...mergedWithOverlappingIds));
-    });
-  });
-  const groupedStructureIds = linkedStructureIds[0];
-  const identityLink = (a, b) => intersection(a, b).length === a.length;
-  const allLinkStructuresLinked = linkedStructureIds.slice(1).reduce((allLinkStructuresLinked2, ids) => {
-    return allLinkStructuresLinked2 && identityLink(ids, groupedStructureIds);
-  }, true);
-  const structureGroups = [groupedStructureIds].filter(Boolean);
-  const linkCheck = [groupedStructureIds].filter(Boolean);
-  const structures = drawDefinition.structures || [];
-  structures.forEach((structure) => {
-    const { structureId, stage } = structure;
-    const existingGroup = structureGroups.find((group) => {
-      return group.includes(structureId);
-    });
-    if (!existingGroup) {
-      structureGroups.push([structureId]);
-      if (stage !== VOLUNTARY_CONSOLATION)
-        linkCheck.push(structureId);
-    }
-  });
-  const allStructuresLinked = allLinkStructuresLinked && linkCheck.length === 1;
-  return {
-    allStructuresLinked,
-    sourceStructureIds,
-    hasDrawFeedProfile,
-    structureGroups
-  };
-}
-
 function getDrawData(params) {
   const {
     tournamentParticipants = [],
@@ -52462,12 +52549,18 @@ function getDrawData(params) {
       }
       return structure;
     }).sort((a, b) => structureSort(a, b, sortConfig)).map((structure) => {
-      const { structureId } = structure;
+      if (!structure)
+        return;
+      const structureId = structure?.structureId;
       let seedAssignments = [];
-      if ([MAIN, CONSOLATION, PLAY_OFF].includes(structure.stage)) {
+      if (structure.stage && [
+        StageTypeEnum.Main,
+        StageTypeEnum.Consolation,
+        StageTypeEnum.PlayOff
+      ].includes(structure.stage)) {
         seedAssignments = mainStageSeedAssignments;
       }
-      if (structure.stage === QUALIFYING) {
+      if (structure?.stage === QUALIFYING) {
         seedAssignments = qualificationStageSeedAssignments;
       }
       const { matchUps, roundMatchUps, roundProfile } = getAllStructureMatchUps({
@@ -52498,7 +52591,7 @@ function getDrawData(params) {
           participantResult: extension.value
         };
       }).filter((f) => f?.participantResult);
-      const structureInfo = (({
+      const structureInfo = structure ? (({
         stageSequence,
         structureName,
         structureType,
@@ -52510,7 +52603,7 @@ function getDrawData(params) {
         structureType,
         matchUpFormat,
         stage
-      }))(structure);
+      }))(structure) : {};
       structureInfo.sourceStructureIds = sourceStructureIds[structureId];
       structureInfo.hasDrawFeedProfile = hasDrawFeedProfile[structureId];
       structureInfo.positionAssignments = positionAssignments;
@@ -54627,7 +54720,7 @@ function getEntryStatusReports({
       drawDefinitionsCount += 1;
       const stageFilter = ({ stage, stageSequence }) => stage === MAIN && stageSequence === 1 || stage === QUALIFYING;
       const structures = params.structures ?? [];
-      const assignedParticipantIds = structures.filter(stageFilter).flatMap(({ positionAssignments }) => positionAssignments).map(({ participantId }) => participantId).filter(Boolean);
+      const assignedParticipantIds = structures.filter(stageFilter).flatMap(({ positionAssignments }) => positionAssignments).filter(Boolean).map(({ participantId }) => participantId);
       const entryFilter = ({ participantId }) => assignedParticipantIds.includes(participantId);
       const createEntryProfile = (params2) => {
         const { participantId, entryStatus, entryStage } = params2;
@@ -59444,7 +59537,10 @@ function isValidForQualifying({ structureId, drawDefinition }) {
   if (result.error)
     return result;
   const targetFeedProfiles = result.links.target.flatMap((t) => t.target.feedProfile).filter(Boolean);
-  const valid = !intersection([BOTTOM_UP, TOP_DOWN, RANDOM], targetFeedProfiles).length;
+  const valid = !intersection(
+    [BOTTOM_UP, TOP_DOWN, RANDOM, WATERFALL],
+    targetFeedProfiles
+  ).length;
   return { ...SUCCESS, valid };
 }