tods-competition-factory 1.6.26 → 1.6.28

package/dist/forge/generate.d.ts

@@ -1463,6 +1463,7 @@ type GenerateDrawDefinitionArgs = {
     qualifyingProfiles?: any[];
     qualifyingOnly?: boolean;
     drawType?: DrawTypeEnum;
+    enforceGender?: boolean;
     matchUpFormat?: string;
     matchUpType?: TypeEnum;
     tieFormatName?: string;

package/dist/forge/generate.mjs

@@ -1382,6 +1382,7 @@ function findPolicy({
 
 const POLICY_TYPE_COMPETITIVE_BANDS = "competitiveBands";
 const POLICY_TYPE_ROUND_ROBIN_TALLY = "roundRobinTally";
+const POLICY_TYPE_MATCHUP_ACTIONS = "matchUpActions";
 const POLICY_TYPE_ROUND_NAMING = "roundNaming";
 const POLICY_TYPE_PARTICIPANT = "participant";
 const POLICY_TYPE_SCHEDULING = "scheduling";
@@ -16224,6 +16225,7 @@ const matchUpFormatCode = {
 };
 
 function validateTieFormat(params) {
+  const checkGender = !!(params?.enforceGender !== false && params?.gender);
   const checkCollectionIds = params?.checkCollectionIds;
   const tieFormat = params?.tieFormat;
   const stack = "validateTieFormat";
@@ -16232,9 +16234,9 @@ function validateTieFormat(params) {
     errors.push("tieFormat must be an object");
     return decorateResult({
       result: {
+        context: { tieFormat, errors },
         error: INVALID_TIE_FORMAT,
-        stack,
-        context: { tieFormat, errors }
+        stack
       }
     });
   }
@@ -16242,9 +16244,9 @@ function validateTieFormat(params) {
     errors.push("tieFormat.winCriteria must be an object");
     return decorateResult({
       result: {
+        context: { tieFormat, errors },
         error: INVALID_TIE_FORMAT,
-        stack,
-        context: { tieFormat, errors }
+        stack
       }
     });
   }
@@ -16252,9 +16254,9 @@ function validateTieFormat(params) {
     errors.push(mustBeAnArray("tieFormat.collectionDefinitions"));
     return decorateResult({
       result: {
+        context: { tieFormat, errors },
         error: INVALID_TIE_FORMAT,
-        stack,
-        context: { tieFormat, errors }
+        stack
       }
     });
   }
@@ -16265,8 +16267,10 @@ function validateTieFormat(params) {
       if ((setValue || scoreValue) && !collectionValue)
         aggregateValueImperative = true;
       const { valid: valid2, errors: collectionDefinitionErrors } = validateCollectionDefinition({
+        referenceGender: params.gender,
         collectionDefinition,
-        checkCollectionIds
+        checkCollectionIds,
+        checkGender
       });
       if (valid2) {
         return true;
@@ -16312,7 +16316,9 @@ function validateTieFormat(params) {
 }
 function validateCollectionDefinition({
   collectionDefinition,
-  checkCollectionIds
+  checkCollectionIds,
+  referenceGender,
+  checkGender
 }) {
   const errors = [];
   if (typeof collectionDefinition !== "object") {
@@ -16331,19 +16337,17 @@ function validateCollectionDefinition({
     matchUpValue,
     matchUpType,
     scoreValue,
-    setValue
+    setValue,
+    gender
   } = collectionDefinition;
   if (checkCollectionIds && typeof collectionId !== "string") {
     errors.push(`collectionId is not type string: ${collectionId}`);
-    return { errors };
   }
   if (typeof matchUpCount !== "number") {
     errors.push(`matchUpCount is not type number: ${matchUpCount}`);
-    return { errors };
   }
   if (matchUpType && ![TypeEnum.Singles, TypeEnum.Doubles].includes(matchUpType)) {
     errors.push(`matchUpType must be SINGLES or DOUBLES: ${matchUpType}`);
-    return { errors };
   }
   const valueDeclarations = [!!collectionValueProfiles?.length].concat(
     [matchUpValue, collectionValue, scoreValue, setValue].map(
@@ -16354,15 +16358,12 @@ function validateCollectionDefinition({
     errors.push(
       "Missing value definition for matchUps: matchUpValue, collectionValue, or collectionValueProfiles"
     );
-    return { errors };
   }
   if (matchUpValue && typeof matchUpValue !== "number") {
     errors.push(`matchUpValue is not type number: ${matchUpValue}`);
-    return { errors };
   }
   if (collectionValue && typeof collectionValue !== "number") {
     errors.push(`collectionValue is not type number: ${collectionValue}`);
-    return { errors };
   }
   if (collectionValueProfiles) {
     const result = validateCollectionValueProfile({
@@ -16371,17 +16372,19 @@ function validateCollectionDefinition({
     });
     if (result.errors) {
       errors.push(...result.errors);
-      return { errors };
     }
   }
   if (collectionGroupNumber && typeof collectionGroupNumber !== "number") {
-    errors.push(`collectionValue is not type number: ${collectionValue}`);
-    return { errors };
+    errors.push(`collectionGroupNumber is not type number: ${collectionValue}`);
   }
   if (matchUpFormat && !matchUpFormatCode.isValid(matchUpFormat)) {
     errors.push(`Invalid matchUpFormat: ${matchUpFormat}`);
-    return { errors };
   }
+  if (checkGender && referenceGender && gender && [GenderEnum.Male, GenderEnum.Female].includes(referenceGender) && referenceGender !== gender) {
+    errors.push(`Invalid gender: ${gender}`);
+  }
+  if (errors.length)
+    return { errors };
   return { valid: true };
 }
 function checkTieFormat(tieFormat) {
@@ -20856,8 +20859,8 @@ function isUngrouped(entryStatus) {
 }
 
 function checkValidEntries({
+  enforceGender = true,
   participants,
-  ignoreGender,
   event
 }) {
   if (!participants)
@@ -20883,7 +20886,7 @@ function checkValidEntries({
     const ungroupedParticipant = eventType && [TypeEnum.Doubles, TypeEnum.Team].includes(eventType) && participant.participantType === INDIVIDUAL && (isUngrouped(entryStatus) || entryStatus === WITHDRAWN);
     const mismatch = participant.participantType !== participantType && !ungroupedParticipant;
     const personGender = participant?.person?.sex;
-    const wrongGender = !ignoreGender && eventGender && eventType === TypeEnum.Singles && [GenderEnum.Male, GenderEnum.Female].includes(eventGender) && personGender !== eventGender;
+    const wrongGender = enforceGender && eventGender && eventType === TypeEnum.Singles && [GenderEnum.Male, GenderEnum.Female].includes(eventGender) && personGender !== eventGender;
     return mismatch || wrongGender;
   });
   if (invalidEntries.length) {
@@ -22664,7 +22667,12 @@ function generateDrawDefinition(params) {
     tournamentRecord,
     inContext: true
   });
-  const validEntriesResult = event && participants && checkValidEntries({ event, participants });
+  const appliedPolicies = getAppliedPolicies({
+    tournamentRecord,
+    event
+  }).appliedPolicies ?? {};
+  const enforceGender = params.enforceGender ?? policyDefinitions?.[POLICY_TYPE_MATCHUP_ACTIONS]?.participants?.enforceGender ?? appliedPolicies?.[POLICY_TYPE_MATCHUP_ACTIONS]?.participants?.enforceGender;
+  const validEntriesResult = event && participants && checkValidEntries({ event, participants, enforceGender });
   if (validEntriesResult?.error)
     return decorateResult({ result: validEntriesResult, stack });
   const allowedDrawTypes = !ignoreAllowedDrawTypes && tournamentRecord && getAllowedDrawTypes({
@@ -22700,11 +22708,6 @@ function generateDrawDefinition(params) {
     (d) => d.drawId === params.drawId
   ) : void 0;
   let { tieFormat, matchUpFormat } = params;
-  if (tieFormat) {
-    const result = validateTieFormat({ tieFormat });
-    if (result.error)
-      return decorateResult({ result, stack });
-  }
   if (matchUpType === TEAM$2 && eventType === TEAM$2) {
     const existingMainTieFormat = existingDrawDefinition?.structures?.find(
       ({ stage }) => stage === MAIN
@@ -22724,6 +22727,15 @@ function generateDrawDefinition(params) {
       matchUpFormat = FORMAT_STANDARD;
     }
   }
+  if (tieFormat) {
+    const result = validateTieFormat({
+      gender: event?.gender,
+      enforceGender,
+      tieFormat
+    });
+    if (result.error)
+      return decorateResult({ result, stack });
+  }
   const invalidDrawId = params.drawId && typeof params.drawId !== "string";
   if (invalidDrawId)
     return decorateResult({ result: { error: INVALID_VALUES }, stack });
@@ -22756,10 +22768,6 @@ function generateDrawDefinition(params) {
         drawDefinition.matchUpType = matchUpType;
     }
   }
-  const appliedPolicies = getAppliedPolicies({
-    tournamentRecord,
-    event
-  }).appliedPolicies ?? {};
   if (policyDefinitions) {
     if (typeof policyDefinitions !== "object") {
       return decorateResult({