tods-competition-factory 1.8.31 → 1.8.33

package/dist/forge/generate.d.ts

@@ -1335,6 +1335,7 @@ type ValidPolicyTypes = typeof POLICY_TYPE_VOLUNTARY_CONSOLATION | typeof POLICY
 type SeedingProfile = {
     groupSeedingThreshold?: number;
     positioning?: string;
+    nonRandom?: boolean;
 };
 type ScaleAttributes = {
     eventType: TypeEnum;
@@ -1511,6 +1512,7 @@ type GenerateDrawDefinitionArgs = {
     ignoreAllowedDrawTypes?: boolean;
     qualifyingPlaceholder?: boolean;
     considerEventEntries?: boolean;
+    seedingProfile?: SeedingProfile;
     hydrateCollections?: boolean;
     tournamentRecord: Tournament;
     drawTypeCoercion?: boolean;

package/dist/forge/generate.mjs

@@ -5409,10 +5409,89 @@ function getSeedGroups({
   }
 }
 
+function getDivisions({ size }) {
+  const divisions = [size];
+  let division = size;
+  while (division / 2 === Math.floor(division / 2)) {
+    division = division / 2;
+    divisions.push(division);
+  }
+  if (!divisions.includes(1))
+    divisions.push(1);
+  divisions.sort(numericSort);
+  divisions.reverse();
+  return divisions;
+}
+function getSubBlock({ blockPattern, index }) {
+  let i = 0;
+  for (const subBlock of blockPattern) {
+    if (i === index)
+      return subBlock;
+    let j = 0;
+    while (j < subBlock.length) {
+      if (i === index)
+        return subBlock;
+      i += 1;
+      j++;
+    }
+  }
+}
+function generateBlockPattern({
+  positioning,
+  size
+}) {
+  const divisions = getDivisions({ size });
+  const divisionGroupings = [];
+  const selected = [];
+  const firstMember = (arr) => arr[0];
+  const lastMember = (arr) => arr[arr.length - 1];
+  const getMember = (arr, i) => (positioning === CLUSTER && i % 2 ? lastMember(arr) : firstMember(arr)) || firstMember(arr);
+  const noneSelected = (chunk, i) => {
+    if (chunk.every((member) => !selected.includes(member))) {
+      const member = getMember(chunk, i);
+      selected.push(member);
+      return member;
+    }
+  };
+  const notSelected = (chunk) => {
+    const notSelected2 = chunk.filter((member) => !selected.includes(member));
+    if (notSelected2.length) {
+      selected.push(...notSelected2);
+      return notSelected2;
+    }
+  };
+  const select = (chunk, i) => {
+    const member = getMember(chunk, i);
+    if (!selected.includes(member)) {
+      selected.push(member);
+      return member;
+    }
+  };
+  const range = generateRange(1, size + 1);
+  for (const division of divisions) {
+    if (division === 1) {
+      const chunks = chunkArray(range, 2);
+      const positions = chunks.map(noneSelected).filter(Boolean);
+      if (positions.length)
+        divisionGroupings.push(positions);
+      const lastPositions = chunks.flatMap(notSelected).filter(Boolean);
+      if (lastPositions.length)
+        divisionGroupings.push(lastPositions);
+    } else {
+      const chunks = chunkArray(range, division);
+      const positions = chunks.map(select).filter(Boolean);
+      if (positions.length)
+        divisionGroupings.push(positions);
+    }
+  }
+  return { divisions, divisionGroupings };
+}
+
 function getValidSeedBlocks({
   provisionalPositioning,
   returnAllProxies,
   appliedPolicies,
+  seedingProfile,
   drawDefinition,
   allPositions,
   structure
@@ -5446,7 +5525,7 @@ function getValidSeedBlocks({
   }).filter((f) => f.length).reverse();
   const firstRoundDrawPositions = uniqueDrawPositionsByRound.pop();
   const firstRoundDrawPositionOffset = firstRoundDrawPositions && Math.min(...firstRoundDrawPositions) - 1 || 0;
-  const seedingProfile = appliedPolicies?.seeding?.seedingProfile;
+  seedingProfile = seedingProfile ?? appliedPolicies?.seeding?.seedingProfile;
   const baseDrawSize = firstRoundDrawPositions?.length || 0;
   const seedRangeDrawPositionBlocks = uniqueDrawPositionsByRound.filter(
     (block) => block.filter((drawPosition) => drawPosition <= seedsCount).length
@@ -5485,12 +5564,14 @@ function getValidSeedBlocks({
       );
       ({ validSeedBlocks } = getSeedBlockPattern({
         drawPositionBlocks: drawPositionChunks,
+        nonRandom: seedingProfile?.nonRandom,
         positioning,
         seedGroups
       }));
     }
   } else if (isContainer) {
     const result = getContainerBlocks({
+      nonRandom: seedingProfile?.nonRandom,
       seedingProfile,
       structure
     });
@@ -5540,7 +5621,7 @@ function getValidSeedBlocks({
     isFeedIn
   };
 }
-function getContainerBlocks({ seedingProfile, structure }) {
+function getContainerBlocks({ seedingProfile, structure, nonRandom }) {
   const containedStructures = structure.structures || [];
   const roundRobinGroupsCount = containedStructures.length;
   const positionAssignments = getPositionAssignments({
@@ -5560,26 +5641,48 @@ function getContainerBlocks({ seedingProfile, structure }) {
   return getSeedBlockPattern({
     drawPositionBlocks,
     positioning,
-    seedGroups
+    seedGroups,
+    nonRandom
   });
 }
-function getSeedBlockPattern({ positioning, seedGroups, drawPositionBlocks }) {
+function getSeedBlockPattern({
+  drawPositionBlocks,
+  positioning,
+  seedGroups,
+  nonRandom
+}) {
   const validSeedBlocks = [];
-  const topDown = (a, b) => a - b;
-  const bottomUp = (a, b) => b - a;
+  const { divisionGroupings } = generateBlockPattern({
+    size: seedGroups.length,
+    positioning
+  });
   const assignedPositions = [];
   seedGroups.forEach((seedGroup, i) => {
-    if (i && positioning !== WATERFALL) {
-      shuffleArray(seedGroup);
-    }
+    const relativePositions = getSubBlock({
+      blockPattern: divisionGroupings,
+      index: i
+    });
     seedGroup.forEach((seedNumber, j) => {
       const blockIndex = i % 2 ? drawPositionBlocks.length - j - 1 : j;
-      const drawPosition = drawPositionBlocks[blockIndex].sort(i % 2 ? bottomUp : topDown).find((drawPosition2) => !assignedPositions.includes(drawPosition2));
-      assignedPositions.push(drawPosition);
-      validSeedBlocks.push({
-        seedNumbers: [seedNumber],
-        drawPositions: [drawPosition]
-      });
+      const block = drawPositionBlocks[blockIndex].slice();
+      let consideredDrawPositions = block.filter(
+        (drawPosition2, i2) => relativePositions.includes(i2 + 1) && drawPosition2
+      );
+      if (positioning !== WATERFALL) {
+        consideredDrawPositions = nonRandom ? consideredDrawPositions : shuffleArray(consideredDrawPositions);
+      } else if (i % 2) {
+        consideredDrawPositions.reverse();
+      }
+      const drawPosition = consideredDrawPositions.find(
+        (drawPosition2) => !assignedPositions.includes(drawPosition2)
+      );
+      if (drawPosition) {
+        assignedPositions.push(drawPosition);
+        validSeedBlocks.push({
+          seedNumbers: [seedNumber],
+          drawPositions: [drawPosition]
+        });
+      }
     });
   });
   return { validSeedBlocks };
@@ -5656,6 +5759,7 @@ function getNextSeedBlock(params) {
   const {
     provisionalPositioning,
     drawDefinition,
+    seedingProfile,
     seedBlockInfo,
     structureId,
     randomize
@@ -5678,6 +5782,7 @@ function getNextSeedBlock(params) {
     provisionalPositioning,
     appliedPolicies,
     drawDefinition,
+    seedingProfile,
     structure
   })?.validSeedBlocks;
   const unfilledSeedBlocks = (validSeedBlocks || []).filter((seedBlock) => {
@@ -12485,6 +12590,7 @@ function getSeedOrderByePositions({
   relevantMatchUps,
   appliedPolicies,
   drawDefinition,
+  seedingProfile,
   seedBlockInfo,
   byesToPlace,
   structure
@@ -12494,6 +12600,7 @@ function getSeedOrderByePositions({
       provisionalPositioning,
       appliedPolicies,
       drawDefinition,
+      seedingProfile,
       structure
     });
   }
@@ -12769,6 +12876,7 @@ function positionByes({
   appliedPolicies,
   drawDefinition,
   seedBlockInfo,
+  seedingProfile,
   matchUpsMap,
   structureId,
   structure,
@@ -12801,6 +12909,7 @@ function positionByes({
     relevantMatchUps,
     appliedPolicies,
     drawDefinition,
+    seedingProfile,
     seedBlockInfo,
     byesToPlace,
     structure
@@ -12976,6 +13085,7 @@ function positionSeedBlocks({
       provisionalPositioning,
       appliedPolicies,
       drawDefinition,
+      seedingProfile,
       structure
     });
     if (result?.error)
@@ -13026,6 +13136,7 @@ function positionSeedBlock({
     provisionalPositioning,
     randomize: true,
     drawDefinition,
+    seedingProfile,
     seedBlockInfo,
     structureId,
     event
@@ -13138,6 +13249,7 @@ function automatedPositioning$1({
     provisionalPositioning,
     appliedPolicies,
     drawDefinition,
+    seedingProfile,
     structure
   });
   if (seedBlockInfo.error)
@@ -19104,7 +19216,7 @@ function getParticipantEntries(params) {
             const minutesDifference = Math.abs(
               consideredMinutes - scheduledMinutes
             );
-            const itemIsPrior = consideredMinutes > scheduledMinutes;
+            const itemIsPrior = consideredMinutes >= scheduledMinutes;
             const timeOverlap = scheduledMinutesDifference && !isNaN(scheduledMinutesDifference) ? minutesDifference <= scheduledMinutesDifference : itemIsPrior && timeStringMinutes(consideredItem.scheduledTime) < timeStringMinutes(notBeforeTime);
             if (timeOverlap && !(bothPotential && sameDraw) && itemIsPrior) {
               participantAggregator.scheduleConflicts.push({
@@ -23203,6 +23315,7 @@ function prepareStage(params) {
     provisionalPositioning,
     appliedPolicies,
     drawDefinition,
+    seedingProfile,
     structure
   }) : void 0;
   const { seedLimit } = initializeStructureSeedAssignments({
@@ -23482,6 +23595,7 @@ function generateDrawDefinition(params) {
     ignoreStageSpace,
     tournamentRecord,
     qualifyingOnly,
+    seedingProfile,
     tieFormatName,
     drawEntries,
     addToEvent,
@@ -23771,6 +23885,7 @@ function generateDrawDefinition(params) {
       // ooo!! If there is no drawSize then MAIN is not being generated
       appliedPolicies,
       drawDefinition,
+      seedingProfile,
       participants,
       stage: MAIN,
       seedsCount,
@@ -23853,7 +23968,6 @@ function generateDrawDefinition(params) {
           seededParticipants,
           seedingScaleName,
           seedsCount: seedsCount2 = 0,
-          seedingProfile,
           seedByRanking,
           placeByes: placeByes2,
           drawSize: drawSize2
@@ -23861,6 +23975,7 @@ function generateDrawDefinition(params) {
         const qualifyingStageResult = prepareStage({
           ...drawTypeResult,
           ...params,
+          seedingProfile: structureProfile.seedingProfile ?? seedingProfile,
           stageSequence: sequence,
           qualifyingRoundNumber,
           preparedStructureIds,
@@ -23871,7 +23986,6 @@ function generateDrawDefinition(params) {
           appliedPolicies,
           drawDefinition,
           qualifyingOnly,
-          seedingProfile,
           seedByRanking,
           participants,
           roundTarget,