tods-competition-factory 2.2.17 → 2.2.18

package/dist/tods-competition-factory.d.ts

@@ -3790,16 +3790,19 @@ declare function generateDrawDefinition(params: GenerateDrawDefinitionArgs): Res
 };
 
 type GenerateQualifyingStructureArgs = {
+    hasExistingDrawDefinition?: boolean;
     appliedPolicies?: PolicyDefinitions;
     qualifyingRoundNumber: number;
     drawDefinition: DrawDefinition;
     qualifyingPositions?: number;
     participantsCount?: number;
     targetStructureId: string;
+    qualifyingOnly?: boolean;
     drawType?: DrawTypeUnion;
     structureOptions?: any;
     matchUpFormat?: string;
     structureName?: string;
+    tieFormat?: TieFormat;
     structureId?: string;
     roundTarget: number;
     drawSize?: number;

package/dist/tods-competition-factory.development.cjs.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.2.17';
+    return '2.2.18';
 }
 
 const SINGLES_MATCHUP = 'SINGLES';
@@ -15719,7 +15719,7 @@ const roundRobinGroups = {
 };
 
 function generateRoundRobin(params) {
-    const { groupNameBase = 'Group', playoffAttributes, stageSequence = 1, structureOptions, appliedPolicies, seedingProfile, stage = MAIN, matchUpType, roundTarget, structureId, groupNames, drawSize, idPrefix, isMock, uuids, } = params;
+    const { hasExistingDrawDefinition, groupNameBase = 'Group', playoffAttributes, stageSequence = 1, structureOptions, appliedPolicies, qualifyingOnly, seedingProfile, stage = MAIN, matchUpType, roundTarget, structureId, groupNames, tieFormat, drawSize, idPrefix, isMock, uuids, } = params;
     const structureName = params.structureName ?? playoffAttributes?.['0']?.name ?? constantToString(MAIN);
     const { groupCount, groupSize } = deriveGroups({
         structureOptions,
@@ -15741,21 +15741,26 @@ function generateRoundRobin(params) {
         const structureName = groupNames?.[structureOrder - 1] ?? `${groupNameBase} ${structureOrder}`;
         return structureTemplate({
             structureId: uuids?.pop(),
+            hasExistingDrawDefinition,
             structureType: ITEM,
             finishingPosition,
+            qualifyingOnly,
             structureOrder,
             structureName,
+            tieFormat,
             matchUps,
         });
     });
     const structure = structureTemplate({
         structureId: structureId ?? uuids?.pop(),
+        hasExistingDrawDefinition,
         structureType: CONTAINER,
         finishingPosition,
         seedingProfile,
         structureName,
         stageSequence,
         structures,
+        tieFormat,
         stage,
     });
     if (roundTarget)
@@ -20078,6 +20083,38 @@ function generateQualifyingLink({ targetEntryRound = 1, finishingPositions, sour
     return { link };
 }
 
+function generateTieMatchUps({ matchUp, tieFormat, isMock, uuids }) {
+    const { collectionDefinitions } = tieFormat ?? {};
+    const tieMatchUps = (collectionDefinitions ?? [])
+        .map((collectionDefinition) => generateCollectionMatchUps({ matchUp, collectionDefinition, uuids, isMock }))
+        .filter(Boolean)
+        .flat();
+    return { tieMatchUps };
+}
+function generateCollectionMatchUps({ collectionPositionOffset = 0, collectionDefinition, matchUpsLimit, matchUp, isMock, uuids, }) {
+    const { matchUpCount, matchUpType, collectionId, processCodes } = collectionDefinition || {};
+    const numberToGenerate = matchUpsLimit ?? matchUpCount ?? 0;
+    const getMatchUpId = (index) => {
+        if (!isMock && !matchUp?.isMock)
+            return uuids?.pop() ?? UUID();
+        const collectionId = collectionDefinition?.collectionId;
+        return uuids?.pop() ?? `${matchUp?.matchUpId}-${collectionId}-TMU-${index + 1}`;
+    };
+    return generateRange(0, numberToGenerate).map((index) => {
+        const collectionPosition = collectionPositionOffset + index + 1;
+        return {
+            sides: [{ sideNumber: 1 }, { sideNumber: 2 }],
+            matchUpId: getMatchUpId(index),
+            matchUpStatus: TO_BE_PLAYED,
+            collectionPosition,
+            collectionId,
+            processCodes,
+            matchUpType,
+            isMock,
+        };
+    });
+}
+
 function generateMatchUpId({ roundPosition, roundNumber, idPrefix, uuids }) {
     return idPrefix ? `${idPrefix}-${roundNumber}-${roundPosition}` : uuids?.pop() || UUID();
 }
@@ -20205,7 +20242,7 @@ function generateQualifyingStructure(params) {
         return decorateResult({ result: { error: INVALID_VALUES }, stack });
     }
     let drawSize = params.drawSize ?? coerceEven(params.participantsCount);
-    const { qualifyingRoundNumber, qualifyingPositions, targetStructureId, structureOptions, appliedPolicies, drawDefinition, matchUpFormat, structureName, structureId, roundTarget, drawType, idPrefix, isMock, uuids, } = params;
+    const { hasExistingDrawDefinition, qualifyingRoundNumber, qualifyingPositions, targetStructureId, structureOptions, appliedPolicies, qualifyingOnly, drawDefinition, matchUpFormat, structureName, structureId, roundTarget, tieFormat, drawType, idPrefix, isMock, uuids, } = params;
     if (!params.drawSize)
         return decorateResult({
             result: { error: MISSING_DRAW_SIZE },
@@ -20245,12 +20282,15 @@ function generateQualifyingStructure(params) {
         const { maxRoundNumber, structures, groupCount } = generateRoundRobin({
             structureName: structureName ?? qualifyingStructureName,
             structureId: structureId ?? uuids?.pop(),
+            hasExistingDrawDefinition,
             stage: QUALIFYING,
             structureOptions,
             appliedPolicies,
+            qualifyingOnly,
             stageSequence,
             matchUpType,
             roundTarget,
+            tieFormat,
             idPrefix,
             drawSize,
             isMock,
@@ -20302,6 +20342,13 @@ function generateQualifyingStructure(params) {
             finishingPositions,
             linkType,
         })?.link;
+    if (tieFormat) {
+        matchUps = getAllStructureMatchUps({ structure })?.matchUps || [];
+        matchUps?.forEach((matchUp) => {
+            const { tieMatchUps } = generateTieMatchUps({ tieFormat, matchUp, isMock });
+            Object.assign(matchUp, { tieMatchUps, matchUpType });
+        });
+    }
     return {
         qualifyingDrawPositionsCount: drawSize,
         qualifiersCount,
@@ -21518,38 +21565,6 @@ function generatePlayoffLink({ playoffStructureId, finishingPositions, sourceStr
     };
 }
 
-function generateTieMatchUps({ matchUp, tieFormat, isMock, uuids }) {
-    const { collectionDefinitions } = tieFormat ?? {};
-    const tieMatchUps = (collectionDefinitions ?? [])
-        .map((collectionDefinition) => generateCollectionMatchUps({ matchUp, collectionDefinition, uuids, isMock }))
-        .filter(Boolean)
-        .flat();
-    return { tieMatchUps };
-}
-function generateCollectionMatchUps({ collectionPositionOffset = 0, collectionDefinition, matchUpsLimit, matchUp, isMock, uuids, }) {
-    const { matchUpCount, matchUpType, collectionId, processCodes } = collectionDefinition || {};
-    const numberToGenerate = matchUpsLimit ?? matchUpCount ?? 0;
-    const getMatchUpId = (index) => {
-        if (!isMock && !matchUp?.isMock)
-            return uuids?.pop() ?? UUID();
-        const collectionId = collectionDefinition?.collectionId;
-        return uuids?.pop() ?? `${matchUp?.matchUpId}-${collectionId}-TMU-${index + 1}`;
-    };
-    return generateRange(0, numberToGenerate).map((index) => {
-        const collectionPosition = collectionPositionOffset + index + 1;
-        return {
-            sides: [{ sideNumber: 1 }, { sideNumber: 2 }],
-            matchUpId: getMatchUpId(index),
-            matchUpStatus: TO_BE_PLAYED,
-            collectionPosition,
-            collectionId,
-            processCodes,
-            matchUpType,
-            isMock,
-        };
-    });
-}
-
 function generateAndPopulateRRplayoffStructures(params) {
     const stack = 'generateAndPopulateRRplayoffStructures';
     if (!params.playoffGroups) {
@@ -21591,11 +21606,7 @@ function generateAndPopulateRRplayoffStructures(params) {
         const tieFormat = resolveTieFormat({ drawDefinition, event })?.tieFormat;
         if (tieFormat) {
             addedMatchUps.forEach((matchUp) => {
-                const { tieMatchUps } = generateTieMatchUps({
-                    isMock: params.isMock,
-                    tieFormat,
-                    matchUp,
-                });
+                const { tieMatchUps } = generateTieMatchUps({ isMock: params.isMock, tieFormat, matchUp });
                 Object.assign(matchUp, { tieMatchUps, matchUpType: TEAM_MATCHUP });
             });
         }
@@ -27091,12 +27102,15 @@ function generateQualifyingStructures({ hasExistingDrawDefinition, qualifyingPro
                 const { structures, groupCount, maxRoundNumber } = generateRoundRobin({
                     structureName: structureProfile.structureName || qualifyingStructureName,
                     structureId: structureId || uuids?.pop(),
+                    hasExistingDrawDefinition,
                     stage: QUALIFYING,
                     structureOptions,
                     appliedPolicies,
+                    qualifyingOnly,
                     stageSequence,
                     matchUpType,
                     roundTarget,
+                    tieFormat,
                     drawSize,
                     idPrefix,
                     isMock,
@@ -27156,6 +27170,13 @@ function generateQualifyingStructures({ hasExistingDrawDefinition, qualifyingPro
             linkType = drawType === ROUND_ROBIN ? POSITION : WINNER;
             finalQualifyingStructureId = structure.structureId;
             finalQualifyingRoundNumber = roundLimit;
+            if (tieFormat) {
+                matchUps = getAllStructureMatchUps({ structure })?.matchUps || [];
+                matchUps?.forEach((matchUp) => {
+                    const { tieMatchUps } = generateTieMatchUps({ tieFormat, matchUp, isMock });
+                    Object.assign(matchUp, { tieMatchUps, matchUpType });
+                });
+            }
             structures.push(structure);
             stageSequence += 1;
         }
@@ -27800,11 +27821,7 @@ function generateDrawTypeAndModifyDrawDefinition(params) {
     if (tieFormat) {
         matchUps?.forEach((matchUp) => {
             if (!existingMatchUpIds.includes(matchUp.matchUpId)) {
-                const { tieMatchUps } = generateTieMatchUps({
-                    tieFormat,
-                    matchUp,
-                    isMock,
-                });
+                const { tieMatchUps } = generateTieMatchUps({ tieFormat, matchUp, isMock });
                 Object.assign(matchUp, { tieMatchUps, matchUpType });
             }
         });
@@ -33146,7 +33163,7 @@ function checkTieFormat({ tieFormat }) {
     return { tieFormat };
 }
 
-function checkFormatScopeEquivalence({ tournamentRecord, drawDefinition, matchUpFormat, matchUpType, tieFormat, event, }) {
+function checkFormatScopeEquivalence({ existingQualifyingStructures, tournamentRecord, drawDefinition, matchUpFormat, matchUpType, tieFormat, event, }) {
     if (matchUpFormat || tieFormat) {
         const equivalentInScope = (matchUpFormat && event?.matchUpFormat === matchUpFormat) ||
             (event?.tieFormat && tieFormat && JSON.stringify(event.tieFormat) === JSON.stringify(tieFormat));
@@ -33155,7 +33172,10 @@ function checkFormatScopeEquivalence({ tournamentRecord, drawDefinition, matchUp
                 const result = checkTieFormat({ tieFormat });
                 if (result.error)
                     return result;
-                drawDefinition.tieFormat = result.tieFormat ?? tieFormat;
+                const existingQualifyingTieFormats = existingQualifyingStructures?.every((structure) => structure.tieFormat);
+                if (!existingQualifyingStructures?.length || existingQualifyingTieFormats) {
+                    drawDefinition.tieFormat = result.tieFormat ?? tieFormat;
+                }
             }
             else if (matchUpFormat) {
                 const result = setMatchUpMatchUpFormat({
@@ -33323,10 +33343,17 @@ function existingPolicyDefinitions({ policyDefinitions, appliedPolicies, policie
 }
 
 function setUpDrawGeneration(params) {
-    const { tournamentRecord, matchUpFormat, appliedPolicies, policyDefinitions, matchUpType, tieFormat, drawType, stack, event, } = params;
+    const { tournamentRecord, policyDefinitions, appliedPolicies, matchUpFormat, matchUpType, tieFormat, drawType, stack, event, } = params;
     const existingDrawDefinition = params.drawId
         ? event?.drawDefinitions?.find((d) => d.drawId === params.drawId)
         : undefined;
+    const structureId = existingDrawDefinition?.structures?.find((structure) => structure.stage === MAIN && structure.stageSequence === 1)?.structureId;
+    const existingQualifyingStructures = existingDrawDefinition
+        ? existingDrawDefinition.structures?.filter((structure) => structure.stage === QUALIFYING)
+        : [];
+    const existingQualifyingPlaceholderStructureId = existingQualifyingStructures?.length === 1 &&
+        !existingQualifyingStructures[0].matchUps?.length &&
+        existingQualifyingStructures[0].structureId;
     if (existingDrawDefinition && drawType !== existingDrawDefinition.drawType)
         existingDrawDefinition.drawType = drawType;
     const drawDefinition = existingDrawDefinition ??
@@ -33336,6 +33363,7 @@ function setUpDrawGeneration(params) {
             drawType,
         });
     const equivalenceResult = checkFormatScopeEquivalence({
+        existingQualifyingStructures,
         tournamentRecord,
         drawDefinition,
         matchUpFormat,
@@ -33348,13 +33376,6 @@ function setUpDrawGeneration(params) {
     const attachmentResult = policyAttachment({ appliedPolicies, policyDefinitions, drawDefinition, stack });
     if (attachmentResult.error)
         return attachmentResult;
-    const structureId = existingDrawDefinition?.structures?.find((structure) => structure.stage === MAIN && structure.stageSequence === 1)?.structureId;
-    const existingQualifyingStructures = existingDrawDefinition
-        ? existingDrawDefinition.structures?.filter((structure) => structure.stage === QUALIFYING)
-        : [];
-    const existingQualifyingPlaceholderStructureId = existingQualifyingStructures?.length === 1 &&
-        !existingQualifyingStructures[0].matchUps?.length &&
-        existingQualifyingStructures[0].structureId;
     return { drawDefinition, structureId, existingDrawDefinition, existingQualifyingPlaceholderStructureId };
 }