tods-competition-factory 2.2.16 → 2.2.17

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

@@ -2874,8 +2874,8 @@ declare function addVoluntaryConsolationStage(params: any): {
 interface ResetQualifyingStructureArgs {
     tournamentRecord?: Tournament;
     drawDefinition: DrawDefinition;
-    event?: Event$1;
     structureId: string;
+    event?: Event$1;
 }
 declare function resetQualifyingStructure({ tournamentRecord, drawDefinition, event, structureId, }: ResetQualifyingStructureArgs): {
     error: {
@@ -3649,6 +3649,7 @@ type GenerateDrawTypeAndModify = {
     matchUpType?: EventTypeUnion;
     drawDefinition: DrawDefinition;
     drawTypeCoercion?: boolean;
+    qualifyingOnly?: boolean;
     modifyOriginal?: boolean;
     qualifiersCount?: number;
     stageSequence?: number;
@@ -3824,6 +3825,7 @@ type GenerateDrawStructuresAndLinksArgs = {
     overwriteExisting?: boolean;
     drawTypeCoercion?: boolean;
     staggeredEntry?: boolean;
+    qualifyingOnly?: boolean;
     qualifyingProfiles?: any;
     structureName?: string;
     tieFormat?: TieFormat;

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.2.16';
+    return '2.2.17';
 }
 
 const SINGLES_MATCHUP = 'SINGLES';
@@ -15575,22 +15575,7 @@ function withdrawParticipantAtDrawPosition(params) {
     return removeDrawPositionAssignment(params);
 }
 
-function capitalizeFirst(str) {
-    return !isString(str)
-        ? str
-        : str
-            .split(' ')
-            .map((name) => name
-            .split('')
-            .map((c, i) => (i ? c.toLowerCase() : c.toUpperCase()))
-            .join(''))
-            .join(' ');
-}
-function constantToString(str) {
-    return !isString(str) ? '' : capitalizeFirst(str.replace(/_/g, ' '));
-}
-
-const structureTemplate = ({ finishingPosition = ROUND_OUTCOME, qualifyingRoundNumber, structureAbbreviation, seedAssignments = [], stageSequence = 1, structureOrder, seedingProfile, matchUpFormat, structureType, structureName, matchUpType, matchUps = [], structureId, roundOffset, roundLimit, stageOrder, structures, stage, }) => {
+const structureTemplate = ({ finishingPosition = ROUND_OUTCOME, hasExistingDrawDefinition, qualifyingRoundNumber, structureAbbreviation, seedAssignments = [], stageSequence = 1, qualifyingOnly, structureOrder, seedingProfile, matchUpFormat, structureType, structureName, matchUps = [], matchUpType, structureId, roundOffset, roundLimit, stageOrder, structures, tieFormat, stage, }) => {
     const structure = {
         structureId: structureId ?? UUID(),
         structureAbbreviation,
@@ -15600,6 +15585,8 @@ const structureTemplate = ({ finishingPosition = ROUND_OUTCOME, qualifyingRoundN
         stageSequence,
         structureName,
     };
+    if (qualifyingOnly || (hasExistingDrawDefinition && tieFormat))
+        structure.tieFormat = tieFormat;
     if (structureOrder)
         structure.structureOrder = structureOrder;
     if (structureType)
@@ -15637,6 +15624,21 @@ const structureTemplate = ({ finishingPosition = ROUND_OUTCOME, qualifyingRoundN
     return structure;
 };
 
+function capitalizeFirst(str) {
+    return !isString(str)
+        ? str
+        : str
+            .split(' ')
+            .map((name) => name
+            .split('')
+            .map((c, i) => (i ? c.toLowerCase() : c.toUpperCase()))
+            .join(''))
+            .join(' ');
+}
+function constantToString(str) {
+    return !isString(str) ? '' : capitalizeFirst(str.replace(/_/g, ' '));
+}
+
 function addVoluntaryConsolationStructure({ structureName = constantToString(VOLUNTARY_CONSOLATION), structureAbbreviation, drawDefinition, matchUpType, structureId, }) {
     if (!drawDefinition)
         return { error: MISSING_DRAW_DEFINITION };
@@ -19728,6 +19730,9 @@ function resetQualifyingStructure({ tournamentRecord, drawDefinition, event, str
     const structure = drawDefinition.structures?.find((structure) => structure.stage === QUALIFYING && structure.structureId === structureId);
     if (!structure)
         return { error: STRUCTURE_NOT_FOUND };
+    const scoresPresent = structure.matchUps?.some(({ matchUpStatus, score }) => checkScoreHasValue({ score }) ?? completedMatchUpStatuses.includes(matchUpStatus));
+    if (scoresPresent)
+        return { error: SCORES_PRESENT };
     const removedMatchUpIds = structure.matchUps?.map(({ matchUpId }) => matchUpId) || [];
     structure.positionAssignments = [];
     structure.seedAssignments = [];
@@ -21919,36 +21924,37 @@ function calculatePercentages({ participantResults, matchUpFormat, tallyPolicy,
     const bestOfGames = parsedGroupMatchUpFormat.bestOf;
     const bracketSetsToWin = (bestOfGames && Math.ceil(bestOfGames / 2)) || 1;
     const bracketGamesForSet = parsedGroupMatchUpFormat.setFormat?.setTo;
+    const precision = Math.pow(10, tallyPolicy?.precision || 3);
     Object.keys(participantResults).forEach((participantId) => {
         const setsWon = participantResults[participantId].setsWon;
         const setsLost = participantResults[participantId].setsLost;
         const setsTotal = tallyPolicy?.groupTotalSetsPlayed
             ? totalSets
             : perPlayer * (bracketSetsToWin || 0) || setsWon + setsLost;
-        let setsPct = Math.round((setsWon / setsTotal) * 1000) / 1000;
+        let setsPct = Math.round((setsWon / setsTotal) * precision) / precision;
         if (setsPct === Infinity || isNaN(setsPct))
             setsPct = setsTotal;
         const tieMatchUpsWon = participantResults[participantId].tieMatchUpsWon;
         const tieMatchUpsLost = participantResults[participantId].tieMatchUpsLost;
         const tieMatchUpsTotal = tieMatchUpsWon + tieMatchUpsLost;
-        let tieMatchUpsPct = Math.round((tieMatchUpsWon / tieMatchUpsTotal) * 1000) / 1000;
+        let tieMatchUpsPct = Math.round((tieMatchUpsWon / tieMatchUpsTotal) * precision) / precision;
         if (tieMatchUpsPct === Infinity || isNaN(tieMatchUpsPct))
             tieMatchUpsPct = tieMatchUpsWon;
         const matchUpsWon = participantResults[participantId].matchUpsWon;
         const matchUpsLost = participantResults[participantId].matchUpsLost;
         const matchUpsTotal = matchUpsWon + matchUpsLost;
-        let matchUpsPct = Math.round((matchUpsWon / matchUpsTotal) * 1000) / 1000;
+        let matchUpsPct = Math.round((matchUpsWon / matchUpsTotal) * precision) / precision;
         if (matchUpsPct === Infinity || isNaN(matchUpsPct))
             matchUpsPct = matchUpsWon;
         const gamesWon = participantResults[participantId].gamesWon || 0;
         const gamesLost = participantResults[participantId].gamesLost || 0;
         const minimumExpectedGames = (perPlayer || 0) * (bracketSetsToWin || 0) * (bracketGamesForSet || 0);
         const gamesTotal = Math.max(minimumExpectedGames, gamesWon + gamesLost);
-        let gamesPct = Math.round((gamesWon / gamesTotal) * 1000) / 1000;
+        let gamesPct = Math.round((gamesWon / gamesTotal) * precision) / precision;
         if (gamesPct === Infinity || isNaN(gamesPct))
             gamesPct = 0;
         const pointsTotal = participantResults[participantId].pointsWon + participantResults[participantId].pointsLost;
-        let pointsPct = Math.round((participantResults[participantId].pointsWon / pointsTotal) * 1000) / 1000;
+        let pointsPct = Math.round((participantResults[participantId].pointsWon / pointsTotal) * precision) / precision;
         if (pointsPct === Infinity || isNaN(pointsPct))
             pointsPct = 0;
         participantResults[participantId].setsWon = setsWon;
@@ -27051,7 +27057,7 @@ var query$b = {
     positionActions: positionActions
 };
 
-function generateQualifyingStructures({ qualifyingProfiles, appliedPolicies, idPrefix, isMock, uuids, }) {
+function generateQualifyingStructures({ hasExistingDrawDefinition, qualifyingProfiles, appliedPolicies, qualifyingOnly, tieFormat, idPrefix, isMock, uuids, }) {
     const stack = 'generateQualifyingSTructures';
     const qualifyingDetails = [];
     const structures = [];
@@ -27115,11 +27121,14 @@ function generateQualifyingStructures({ qualifyingProfiles, appliedPolicies, idP
                     structureName: structureProfile.structureName || qualifyingStructureName,
                     structureId: structureId || uuids?.pop(),
                     qualifyingRoundNumber: roundLimit,
+                    hasExistingDrawDefinition,
                     stage: QUALIFYING,
+                    qualifyingOnly,
                     matchUpFormat,
                     stageSequence,
                     matchUpType,
                     roundLimit,
+                    tieFormat,
                     matchUps,
                 });
                 if (roundTarget) {
@@ -27457,7 +27466,7 @@ function luckyRoundProfiles(drawSize) {
 }
 
 function getGenerators(params) {
-    const { playoffAttributes, stageSequence = 1, stage = MAIN, matchUpType, drawSize, uuids } = params;
+    const { playoffAttributes, stageSequence = 1, stage = MAIN, tieFormat, matchUpType, drawSize, uuids } = params;
     const getPrefixedStructureId = () => {
         if (!params.isMock && !params.idPrefix)
             return undefined;
@@ -27476,6 +27485,7 @@ function getGenerators(params) {
             structureName,
             matchUpType,
             structureId,
+            tieFormat,
             matchUps,
             stage,
         });
@@ -27529,6 +27539,7 @@ function getGenerators(params) {
                 matchUpType,
                 structureId,
                 stage: MAIN,
+                tieFormat,
                 matchUps,
             });
             return { structures: [structure], links: [], ...SUCCESS };
@@ -27548,7 +27559,7 @@ function getGenerators(params) {
 }
 
 function generateDrawStructuresAndLinks(params) {
-    const { enforceMinimumDrawSize = true, overwriteExisting, appliedPolicies, staggeredEntry, drawDefinition, tieFormat, isMock, uuids, } = params || {};
+    const { enforceMinimumDrawSize = true, overwriteExisting, appliedPolicies, qualifyingOnly, staggeredEntry, drawDefinition, tieFormat, isMock, uuids, } = params || {};
     const drawSize = ensureInt(params.drawSize);
     const drawTypeCoercion = params.drawTypeCoercion ?? getDrawTypeCoercion({ appliedPolicies, drawType: params.drawType });
     const stack = 'generateDrawStructuresAndLinks';
@@ -27613,6 +27624,8 @@ function generateDrawStructuresAndLinks(params) {
             idPrefix: params.idPrefix,
             qualifyingProfiles,
             appliedPolicies,
+            qualifyingOnly,
+            tieFormat,
             isMock,
             uuids,
         });
@@ -32383,13 +32396,16 @@ function getDrawFormat(params) {
 
 function processExistingDrawDefinition(params) {
     const drawDefinition = params.drawDefinition;
-    const { existingQualifyingPlaceholderStructureId, appliedPolicies, drawEntries, structureId, idPrefix, isMock, event, } = params;
+    const { existingQualifyingPlaceholderStructureId, appliedPolicies, qualifyingOnly, drawEntries, structureId, tieFormat, idPrefix, isMock, event, } = params;
     const qualifyingProfiles = params.qualifyingProfiles;
     const qualifyingResult = qualifyingProfiles?.length
         ? generateQualifyingStructures({
+            hasExistingDrawDefinition: true,
             uuids: params.uuids,
             qualifyingProfiles,
             appliedPolicies,
+            qualifyingOnly,
+            tieFormat,
             idPrefix,
             isMock,
         })
@@ -33375,7 +33391,7 @@ function generateOrGetExisting(params) {
 }
 
 function qualifyingGeneration(params) {
-    const { qualifyingPlaceholder, qualifyingProfiles, existingDrawDefinition, positioningReports, appliedPolicies, qualifyingOnly, drawDefinition, seedingProfile, participants, structureId, entries, stack, } = params;
+    const { qualifyingPlaceholder, existingDrawDefinition, positioningReports, qualifyingProfiles, appliedPolicies, qualifyingOnly, drawDefinition, seedingProfile, participants, structureId, tieFormat, entries, stack, } = params;
     const generateQualifyingPlaceholder = qualifyingPlaceholder && !qualifyingProfiles?.length && !existingDrawDefinition;
     const qualifyingConflicts = [];
     if (qualifyingProfiles) {
@@ -33438,6 +33454,8 @@ function qualifyingGeneration(params) {
         const qualifyingStructure = structureTemplate({
             structureName: constantToString(QUALIFYING),
             stage: QUALIFYING,
+            qualifyingOnly,
+            tieFormat,
         });
         const { link } = generateQualifyingLink({
             sourceStructureId: qualifyingStructure.structureId,