tods-competition-factory 1.6.26 → 1.6.28

package/dist/index.mjs

@@ -329,7 +329,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.6.26";
+  return "1.6.28";
 }
 
 function getObjectTieFormat(obj) {
@@ -2445,6 +2445,7 @@ var ParticipantTypeEnum = /* @__PURE__ */ ((ParticipantTypeEnum2) => {
 })(ParticipantTypeEnum || {});
 
 function validateTieFormat(params) {
+  const checkGender = !!(params?.enforceGender !== false && params?.gender);
   const checkCollectionIds = params?.checkCollectionIds;
   const tieFormat = params?.tieFormat;
   const stack = "validateTieFormat";
@@ -2453,9 +2454,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
       }
     });
   }
@@ -2463,9 +2464,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
       }
     });
   }
@@ -2473,9 +2474,9 @@ function validateTieFormat(params) {
     errors.push(mustBeAnArray("tieFormat.collectionDefinitions"));
     return decorateResult({
       result: {
+        context: { tieFormat, errors },
         error: INVALID_TIE_FORMAT,
-        stack,
-        context: { tieFormat, errors }
+        stack
       }
     });
   }
@@ -2486,8 +2487,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;
@@ -2533,7 +2536,9 @@ function validateTieFormat(params) {
 }
 function validateCollectionDefinition({
   collectionDefinition,
-  checkCollectionIds
+  checkCollectionIds,
+  referenceGender,
+  checkGender
 }) {
   const errors = [];
   if (typeof collectionDefinition !== "object") {
@@ -2552,19 +2557,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(
@@ -2575,15 +2578,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({
@@ -2592,17 +2592,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) {
@@ -51389,6 +51391,7 @@ function getEventData(params) {
     // order is important!!
     tournamentRecord
   });
+  const stageFilter = ({ stage }) => !usePublishState || !publishStatus?.stages?.length || publishStatus.stages.includes(stage);
   const structureFilter = ({ structureId }) => !usePublishState || !publishStatus?.structureIds?.length || publishStatus.structureIds.includes(structureId);
   const drawFilter = ({ drawId }) => !usePublishState || !publishStatus?.drawIds?.length || publishStatus.drawIds.includes(drawId);
   const drawDefinitions = event.drawDefinitions || [];
@@ -51411,7 +51414,7 @@ function getEventData(params) {
     )
   ).map(({ structures, ...drawData }) => ({
     ...drawData,
-    structures: structures?.filter(structureFilter)
+    structures: structures?.filter(structureFilter)?.filter(stageFilter)
   })).filter((drawData) => drawData.structures?.length);
   const { tournamentInfo } = getTournamentInfo({ tournamentRecord });
   const venues = tournamentRecord.venues || [];
@@ -51466,15 +51469,17 @@ function getEventData(params) {
 }
 
 function publishEvent(params) {
-  let { policyDefinitions, drawIds, structureIds } = params;
+  let { policyDefinitions, drawIds, structureIds, stages } = params;
   const {
+    includePositionAssignments,
     removePriorValues,
     tournamentRecord,
     status = PUBLIC,
     event,
     drawIdsToRemove,
     drawIdsToAdd,
-    includePositionAssignments,
+    stagesToRemove,
+    stagesToAdd,
     structureIdsToRemove,
     structureIdsToAdd
   } = params;
@@ -51508,25 +51513,36 @@ function publishEvent(params) {
     );
   }
   if (!structureIds && (structureIdsToAdd?.length || structureIdsToRemove?.length)) {
-    structureIds = timeItem?.itemValue?.PUBLIC?.drawIds || [];
+    structureIds = timeItem?.itemValue?.PUBLIC?.structureIds || [];
   }
   structureIds = (structureIds || []).filter(
     (structureId) => !structureIdsToRemove?.length || !structureIdsToRemove.includes(structureId)
   );
   if (structureIdsToAdd?.length) {
-    structureIds = unique(structureIds.push(...structureIdsToAdd));
+    structureIds = unique(structureIds.concat(...structureIdsToAdd));
+  }
+  if (!stages && (stagesToAdd?.length || stagesToRemove?.length)) {
+    stages = timeItem?.itemValue?.PUBLIC?.stages || [];
+  }
+  stages = (stages || []).filter(
+    (stage) => !stagesToRemove?.length || !stagesToRemove.includes(stage)
+  );
+  if (stagesToAdd?.length) {
+    stages = unique(stages.concat(...stagesToAdd));
   }
   const existingStatusValue = timeItem?.itemValue?.[status];
   const updatedTimeItem = {
-    itemValue: { [status]: { ...existingStatusValue, drawIds, structureIds } },
+    itemValue: {
+      [status]: { ...existingStatusValue, drawIds, structureIds, stages }
+    },
     itemType
   };
   addEventTimeItem({ event, timeItem: updatedTimeItem, removePriorValues });
   const { eventData } = getEventData({
     includePositionAssignments,
     usePublishState: true,
-    policyDefinitions,
     tournamentRecord,
+    policyDefinitions,
     event
   });
   const publishState = eventData?.eventInfo?.publish?.state;
@@ -54715,8 +54731,8 @@ function addEventEntryPairs({
 }
 
 function checkValidEntries({
+  enforceGender = true,
   participants,
-  ignoreGender,
   event
 }) {
   if (!participants)
@@ -54742,7 +54758,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) {
@@ -57342,7 +57358,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({
@@ -57378,11 +57399,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
@@ -57402,6 +57418,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 });
@@ -57434,10 +57459,6 @@ function generateDrawDefinition(params) {
         drawDefinition.matchUpType = matchUpType;
     }
   }
-  const appliedPolicies = getAppliedPolicies({
-    tournamentRecord,
-    event
-  }).appliedPolicies ?? {};
   if (policyDefinitions) {
     if (typeof policyDefinitions !== "object") {
       return decorateResult({