tods-competition-factory 2.2.32-beta.6 → 2.2.33

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

@@ -2533,6 +2533,7 @@ type GenerateDrawDefinitionArgs = {
     hydrateCollections?: boolean;
     tournamentRecord: Tournament;
     matchUpType?: EventTypeUnion;
+    hydrateRoundNames?: boolean;
     drawTypeCoercion?: boolean;
     ignoreStageSpace?: boolean;
     qualifyingProfiles?: any[];
@@ -4625,11 +4626,11 @@ declare function deleteFlightProfileAndFlightDraws({ autoPublish, tournamentReco
     event: any;
     force: any;
 }): {
+    error: any;
+} | {
     success?: boolean;
     error?: ErrorType;
     info?: any;
-} | {
-    error: any;
 };
 
 type ModifyEventMatchUpFormatTimingArgs = {
@@ -5738,6 +5739,7 @@ declare function bulkMatchUpStatusUpdate(params: any): ResultType | {
         message: string;
         code: string;
     };
+    info?: undefined;
 } | {
     error: {
         message: string;

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.2.32-beta.6';
+    return '2.2.33';
 }
 
 const SINGLES_MATCHUP = 'SINGLES';
@@ -38436,10 +38436,13 @@ function getConsideredEntries({ considerEventEntries = true, drawEntries, eventE
 }
 function getPolicies(params) {
     const { tournamentRecord, event } = params;
-    const appliedPolicies = getAppliedPolicies({
-        tournamentRecord,
-        event,
-    }).appliedPolicies ?? {};
+    const appliedPolicies = {
+        ...params?.appliedPolicies,
+        ...(getAppliedPolicies({
+            tournamentRecord,
+            event,
+        }).appliedPolicies ?? {}),
+    };
     const policyDefinitions = makeDeepCopy(params.policyDefinitions ?? {}, false, true);
     return { appliedPolicies, policyDefinitions };
 }
@@ -38556,6 +38559,41 @@ function generateDrawDefinition(params) {
             matchUpType,
         });
     }
+    if (params.hydrateRoundNames) {
+        const roundNamingPolicy = appliedPolicies?.[POLICY_TYPE_ROUND_NAMING];
+        if (roundNamingPolicy) {
+            const matchUpsMap = getMatchUpsMap({ drawDefinition });
+            drawDefinition.structures?.forEach((structure) => {
+                const matchUps = getMappedStructureMatchUps({
+                    structureId: structure.structureId,
+                    matchUpsMap,
+                });
+                const result = getRoundContextProfile({
+                    roundNamingPolicy,
+                    drawDefinition,
+                    structure,
+                    matchUps,
+                });
+                const { roundNamingProfile, roundProfile } = result;
+                const structures = structure.structures || [structure];
+                structures.forEach((itemStructure) => {
+                    (itemStructure.matchUps ?? []).forEach((matchUp) => {
+                        const roundNumber = matchUp?.roundNumber?.toString();
+                        if (roundNumber) {
+                            const roundName = roundNamingProfile?.[roundNumber]?.roundName;
+                            const abbreviatedRoundName = roundNamingProfile?.[roundNumber]?.abbreviatedRoundName;
+                            const feedRound = roundProfile?.[roundNumber]?.feedRound;
+                            Object.assign(matchUp, {
+                                abbreviatedRoundName,
+                                feedRound,
+                                roundName,
+                            });
+                        }
+                    });
+                });
+            });
+        }
+    }
     return {
         existingDrawDefinition: !!existingDrawDefinition,
         qualifyingConflicts,
@@ -45354,9 +45392,7 @@ function setMatchUpState(params) {
     const isClearScore = matchUpStatus === TO_BE_PLAYED && score?.scoreStringSide1 === '' && score?.scoreStringSide2 === '' && !winningSide;
     const propagatedExitDownStream = hasPropagatedExitDownstream(params);
     if (propagatedExitDownStream && isClearScore) {
-        return {
-            error: PROPAGATED_EXITS_DOWNSTREAM,
-        };
+        return { error: PROPAGATED_EXITS_DOWNSTREAM };
     }
     const activeDownstream = isActiveDownstream(params);
     let dualWinningSideChange;