tods-competition-factory 1.8.23 → 1.8.24

package/dist/forge/query.mjs

@@ -6760,7 +6760,8 @@ const POLICY_ROUND_NAMING_DEFAULT = {
   [POLICY_TYPE_ROUND_NAMING]: {
     policyName: "Round Naming Default",
     namingConventions: {
-      round: "Round"
+      round: "Round",
+      pre: "Pre"
     },
     qualifyingFinishMap: {
       1: "Final"
@@ -6804,12 +6805,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 || {};
@@ -6833,6 +6833,7 @@ function getRoundContextProfile({
       })
     );
   } else {
+    const qualifyingFinishgMap = isQualifying && (roundNamingPolicy?.qualifyingFinishMap || defaultRoundNamingPolicy?.qualifyingFinishMap || {});
     Object.assign(
       roundNamingProfile,
       ...roundProfileKeys.map((round) => {
@@ -14557,13 +14558,42 @@ function positionActions(params) {
 
 const hasParticipantId = (o) => o?.participantId;
 
-function getStructureGroups({ drawDefinition }) {
+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] || [],
@@ -14571,6 +14601,56 @@ function getStructureGroups({ drawDefinition }) {
     ]).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) => {
@@ -14589,7 +14669,6 @@ function getStructureGroups({ drawDefinition }) {
   }, 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) => {
@@ -14598,12 +14677,17 @@ function getStructureGroups({ drawDefinition }) {
     if (!existingGroup) {
       structureGroups.push([structureId]);
       if (stage !== VOLUNTARY_CONSOLATION)
-        linkCheck.push(structureId);
+        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
@@ -14668,12 +14752,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({
@@ -14704,7 +14794,7 @@ function getDrawData(params) {
           participantResult: extension.value
         };
       }).filter((f) => f?.participantResult);
-      const structureInfo = (({
+      const structureInfo = structure ? (({
         stageSequence,
         structureName,
         structureType,
@@ -14716,7 +14806,7 @@ function getDrawData(params) {
         structureType,
         matchUpFormat,
         stage
-      }))(structure);
+      }))(structure) : {};
       structureInfo.sourceStructureIds = sourceStructureIds[structureId];
       structureInfo.hasDrawFeedProfile = hasDrawFeedProfile[structureId];
       structureInfo.positionAssignments = positionAssignments;