tods-competition-factory 2.2.17 → 2.2.19

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.19';
 }
 
 const SINGLES_MATCHUP = 'SINGLES';
@@ -10261,14 +10261,14 @@ function addMatchUpContext({ scheduleVisibilityFilters, sourceDrawPositionRanges
         tournamentRecord?.processCodes;
     const competitiveProfile = contextProfile?.withCompetitiveness && getMatchUpCompetitiveProfile({ ...contextContent, matchUp });
     const finishingPositionRange = matchUp.finishingPositionRange ?? additionalContext.finishingPositionRange;
+    const roundOfPlay = stage !== QUALIFYING && isConvertableInteger(initialRoundOfPlay) && initialRoundOfPlay + (roundNumber || 0);
     const onlyDefined = (obj) => definedAttributes(obj, undefined, true);
     const matchUpWithContext = {
         ...onlyDefined(context),
         ...onlyDefined({
-            matchUpFormat: matchUp.matchUpType === TEAM$1 ? undefined : matchUpFormat,
-            tieFormat: matchUp.matchUpType !== TEAM$1 ? undefined : tieFormat,
+            matchUpFormat: matchUpType === TEAM$1 ? undefined : matchUpFormat,
+            tieFormat: matchUpType !== TEAM$1 ? undefined : tieFormat,
             gender: collectionDefinition?.gender ?? event?.gender,
-            roundOfPlay: stage !== QUALIFYING && isConvertableInteger(initialRoundOfPlay) && initialRoundOfPlay + (roundNumber || 0),
             endDate: matchUp.endDate ?? endDate,
             discipline: event?.discipline,
             category: matchUpCategory,
@@ -10289,6 +10289,7 @@ function addMatchUpContext({ scheduleVisibilityFilters, sourceDrawPositionRanges
             roundOffset,
             structureId,
             roundNumber,
+            roundOfPlay,
             feedRound,
             roundName,
             drawName,
@@ -15719,7 +15720,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 +15742,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 +20084,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 +20243,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 +20283,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 +20343,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 +21566,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 +21607,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 +27103,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 +27171,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 +27822,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 +33164,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 +33173,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 +33344,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 +33364,7 @@ function setUpDrawGeneration(params) {
             drawType,
         });
     const equivalenceResult = checkFormatScopeEquivalence({
+        existingQualifyingStructures,
         tournamentRecord,
         drawDefinition,
         matchUpFormat,
@@ -33348,13 +33377,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 };
 }
 
@@ -58469,7 +58491,7 @@ function executeFunction(engine, method, params, methodName, engineType) {
     const augmentedParams = params ? paramsMiddleware(tournamentRecords, params) : undefined;
     if (augmentedParams?.error)
         return augmentedParams;
-    const result = invoke({
+    const result = invoke$1({
         params: augmentedParams,
         tournamentRecords,
         tournamentRecord,
@@ -58480,7 +58502,7 @@ function executeFunction(engine, method, params, methodName, engineType) {
     engineLogging({ result, methodName, elapsed, params: paramsToLog, engineType });
     return result;
 }
-function invoke({ tournamentRecords, tournamentRecord, params, methodName, method }) {
+function invoke$1({ tournamentRecords, tournamentRecord, params, methodName, method }) {
     if (getDevContext()) {
         return method({ tournamentRecords, tournamentRecord, ...params });
     }
@@ -58988,58 +59010,58 @@ const matchUpEngine = (() => {
         }
         return engine;
     }
-    importGovernors([scoreGovernor]);
+    importGovernors(engine, [scoreGovernor]);
     return engine;
-    function importGovernors(governors) {
-        governors.forEach((governor) => {
-            Object.keys(governor).forEach((methodName) => {
-                engine[methodName] = (params) => {
-                    if (getDevContext()) {
-                        return invoke({ params, governor, methodName });
+})();
+function importGovernors(engine, governors) {
+    governors.forEach((governor) => {
+        Object.keys(governor).forEach((methodName) => {
+            engine[methodName] = (params) => {
+                if (getDevContext()) {
+                    return invoke(engine, { params, governor, methodName });
+                }
+                else {
+                    try {
+                        return invoke(engine, { params, governor, methodName });
                     }
-                    else {
-                        try {
-                            return invoke({ params, governor, methodName });
-                        }
-                        catch (err) {
-                            handleCaughtError({
-                                engineName: 'matchUpEngine',
-                                methodName,
-                                params,
-                                err,
-                            });
-                        }
+                    catch (err) {
+                        handleCaughtError({
+                            engineName: 'matchUpEngine',
+                            methodName,
+                            params,
+                            err,
+                        });
                     }
-                };
-            });
+                }
+            };
         });
+    });
+}
+function invoke(engine, { params, governor, methodName }) {
+    engine.error = undefined;
+    engine.success = false;
+    const matchUp = params?.matchUp || getMatchUp();
+    const matchUps = params?.matchUps || getMatchUps();
+    const snapshot = params?.rollbackOnError && makeDeepCopy(matchUp, false, true);
+    params = {
+        ...params,
+        matchUpId: matchUp?.matchUpId,
+        matchUps,
+        matchUp,
+    };
+    const result = governor[methodName](params);
+    if (result?.error) {
+        if (snapshot)
+            setState(snapshot);
+        return { ...result, rolledBack: !!snapshot };
     }
-    function invoke({ params, governor, methodName }) {
-        engine.error = undefined;
-        engine.success = false;
-        const matchUp = params?.matchUp || getMatchUp();
-        const matchUps = params?.matchUps || getMatchUps();
-        const snapshot = params?.rollbackOnError && makeDeepCopy(matchUp, false, true);
-        params = {
-            ...params,
-            matchUpId: matchUp?.matchUpId,
-            matchUps,
-            matchUp,
-        };
-        const result = governor[methodName](params);
-        if (result?.error) {
-            if (snapshot)
-                setState(snapshot);
-            return { ...result, rolledBack: !!snapshot };
-        }
-        const notify = result?.success && params?.delayNotify !== true && params?.doNotNotify !== true;
-        if (notify)
-            notifySubscribers();
-        if (notify || !result?.success || params?.doNotNotify)
-            deleteNotices();
-        return result;
-    }
-})();
+    const notify = result?.success && params?.delayNotify !== true && params?.doNotNotify !== true;
+    if (notify)
+        notifySubscribers();
+    if (notify || !result?.success || params?.doNotNotify)
+        deleteNotices();
+    return result;
+}
 
 let devContextSet = false;
 const mocksEngine = (() => {