tods-competition-factory 1.8.19 → 1.8.21

package/dist/forge/generate.mjs

@@ -4308,6 +4308,9 @@ const POLICY_ROUND_NAMING_DEFAULT = {
     namingConventions: {
       round: "Round"
     },
+    qualifyingFinishMap: {
+      1: "Final"
+    },
     abbreviatedRoundNamingMap: {
       // key is matchUpsCount for the round
       1: "F",
@@ -4321,7 +4324,8 @@ const POLICY_ROUND_NAMING_DEFAULT = {
     },
     affixes: {
       roundNumber: "R",
-      preFeedRound: "Q"
+      preFeedRound: "Q",
+      preQualifying: "P"
     },
     stageConstants: {
       [MAIN]: "",
@@ -4334,6 +4338,7 @@ const POLICY_ROUND_NAMING_DEFAULT = {
 
 function getRoundContextProfile({
   roundNamingPolicy,
+  drawDefinition,
   structure,
   matchUps
 }) {
@@ -4344,21 +4349,31 @@ function getRoundContextProfile({
   const isRoundRobin = structure.structures;
   const roundNamingProfile = {};
   const defaultRoundNamingPolicy = POLICY_ROUND_NAMING_DEFAULT[POLICY_TYPE_ROUND_NAMING];
+  const isQualifying = structure.stage === QUALIFYING;
+  const qualifyingFinishgMap = isQualifying && (roundNamingPolicy?.qualifyingFinishMap || defaultRoundNamingPolicy?.qualifyingFinishMap || {});
+  const qualifyingStageSequences = isQualifying ? Math.max(
+    ...(drawDefinition?.structures ?? []).filter((structure2) => structure2.stage === QUALIFYING).map(({ stageSequence }) => stageSequence ?? 1),
+    0
+  ) : 0;
+  const preQualifyingSequence = qualifyingStageSequences ? qualifyingStageSequences - (structure.stageSequence || 1) || "" : "";
+  const preQualifyingAffix = preQualifyingSequence ? roundNamingPolicy?.affixes?.preQualifying || defaultRoundNamingPolicy.affixes.preQualifying || "" : "";
   const roundNamingMap = roundNamingPolicy?.roundNamingMap || defaultRoundNamingPolicy.roundNamingMap || {};
   const abbreviatedRoundNamingMap = roundNamingPolicy?.abbreviatedRoundNamingMap || defaultRoundNamingPolicy.abbreviatedRoundNamingMap || {};
-  const roundNamePrefix = roundNamingPolicy?.affixes || defaultRoundNamingPolicy.affixes;
-  const roundNumberAffix = roundNamePrefix.roundNumber || defaultRoundNamingPolicy.affixes.roundNumber;
+  const preFeedAffix = roundNamingPolicy?.affixes?.preFeedRound || defaultRoundNamingPolicy.affixes.preFeedRound;
+  const roundNumberAffix = roundNamingPolicy?.affixes?.roundNumber || defaultRoundNamingPolicy.affixes.roundNumber;
   const namingConventions = roundNamingPolicy?.namingConventions || defaultRoundNamingPolicy.namingConventions;
   const roundNameFallback = namingConventions.round;
-  const stageInitial = stage && stage !== MAIN && stage[0];
-  const stageConstants = roundNamingPolicy?.stageConstants;
-  const stageConstant = stage && stageConstants?.[stage] || stageInitial;
+  const stageInitial = stage && stage !== MAIN ? stage[0] : "";
+  const stageConstants = roundNamingPolicy?.stageConstants || defaultRoundNamingPolicy.stageConstants;
+  const stageIndicator = stage && stageConstants?.[stage] || stageInitial;
+  const stageConstant = `${preQualifyingAffix}${stageIndicator}${preQualifyingSequence}`;
   const roundProfileKeys = roundProfile ? Object.keys(roundProfile) : [];
+  const qualifyingAffix = isQualifying && stageConstants?.[QUALIFYING] ? `${stageConstants?.[QUALIFYING]}-` : "";
   if (isRoundRobin || isAdHocStructure || isLuckyStructure) {
     Object.assign(
       roundNamingProfile,
       ...roundProfileKeys.map((key) => {
-        const roundName = `${roundNameFallback} ${key}`;
+        const roundName = `${qualifyingAffix}${roundNameFallback} ${key}`;
         const abbreviatedRoundName = `${roundNumberAffix}${key}`;
         return { [key]: { roundName, abbreviatedRoundName } };
       })
@@ -4371,15 +4386,15 @@ function getRoundContextProfile({
           return;
         const { matchUpsCount, preFeedRound } = roundProfile[round];
         const participantsCount = matchUpsCount * 2;
-        const sizedRoundName = roundNamingMap[matchUpsCount] || `${roundNamePrefix.roundNumber}${participantsCount}`;
-        const suffix = preFeedRound ? `-${roundNamePrefix.preFeedRound}` : "";
+        const sizedRoundName = qualifyingFinishgMap?.[roundProfile?.[round].finishingRound] || qualifyingFinishgMap && `${roundNumberAffix}${participantsCount}` || roundNamingMap[matchUpsCount] || `${roundNumberAffix}${participantsCount}`;
+        const suffix = preFeedRound ? `-${preFeedAffix}` : "";
         const profileRoundName = `${sizedRoundName}${suffix}`;
         const roundName = [
           stageConstant,
           structureAbbreviation,
           profileRoundName
         ].filter(Boolean).join("-");
-        const sizedAbbreviation = abbreviatedRoundNamingMap[matchUpsCount] || `${roundNamePrefix.roundNumber}${participantsCount}`;
+        const sizedAbbreviation = abbreviatedRoundNamingMap[matchUpsCount] || `${roundNumberAffix}${participantsCount}`;
         const profileAbbreviation = `${sizedAbbreviation}${suffix}`;
         const abbreviatedRoundName = [
           stageConstant,
@@ -4552,6 +4567,7 @@ function getAllStructureMatchUps({
   const roundNamingPolicy = appliedPolicies?.[POLICY_TYPE_ROUND_NAMING];
   const result = getRoundContextProfile({
     roundNamingPolicy,
+    drawDefinition,
     structure,
     matchUps
   });
@@ -16752,8 +16768,8 @@ function validateCollectionDefinition({
   if (checkGender && referenceGender && gender && [GenderEnum.Male, GenderEnum.Female].includes(referenceGender) && referenceGender !== gender) {
     errors.push(`Invalid gender: ${gender}`);
     return decorateResult({
+      result: { error: INVALID_GENDER, errors },
       context: { referenceGender, gender },
-      result: { error: INVALID_GENDER },
       stack
     });
   }
@@ -21397,25 +21413,65 @@ function isUngrouped(entryStatus) {
   return [UNPAIRED, UNGROUPED].includes(entryStatus);
 }
 
+const POLICY_MATCHUP_ACTIONS_DEFAULT = {
+  [POLICY_TYPE_MATCHUP_ACTIONS]: {
+    policyName: "matchUpActionsDefault",
+    // matchUpActions will be selectively enabled for structures matching { stages: [], stageSequences: [] }
+    // enabledStructures: [] => all structures are enabled
+    enabledStructures: [
+      {
+        stages: [],
+        // stages: [] => applies to all stages
+        stageSequences: [],
+        // stageSequences: [] => applies to all stageSequences
+        enabledActions: [],
+        disabledActions: []
+        // disabledActions: [] => no actions are disabled
+      }
+    ],
+    participants: {
+      enforceCategory: true,
+      // validate collectionDefinition.category against event.category
+      enforceGender: true
+      // disallow placing FEMALEs in MALE events and vice versa
+    },
+    processCodes: {
+      substitution: ["RANKING.IGNORE", "RATING.IGNORE"]
+    },
+    substituteAfterCompleted: false,
+    substituteWithoutScore: false
+  }
+};
+
 function checkValidEntries({
-  enforceGender = true,
   consideredEntries,
+  policyDefinitions,
   tournamentRecord,
+  appliedPolicies,
+  participantMap,
+  enforceGender,
   participants,
   event
 }) {
-  participants = participants || tournamentRecord?.participants;
+  if ((!participants || !participantMap) && tournamentRecord) {
+    ({ participants, participantMap } = getParticipants({
+      tournamentRecord
+    }));
+  }
   if (!participants)
     return { error: MISSING_PARTICIPANTS };
   if (!Array.isArray(participants))
     return { error: INVALID_VALUES };
   if (!event)
     return { error: MISSING_EVENT };
+  const matchUpActionsPolicy = policyDefinitions?.[POLICY_TYPE_MATCHUP_ACTIONS] ?? appliedPolicies?.[POLICY_TYPE_MATCHUP_ACTIONS] ?? POLICY_MATCHUP_ACTIONS_DEFAULT[POLICY_TYPE_MATCHUP_ACTIONS];
+  const genderEnforced = (enforceGender ?? matchUpActionsPolicy?.participants?.enforceGender) !== false;
   const { eventType, gender: eventGender } = event;
-  const participantType = eventType === TEAM_EVENT && TEAM || eventType === DOUBLES_EVENT && PAIR || INDIVIDUAL;
+  const isDoubles = eventType === DOUBLES_EVENT;
+  const participantType = eventType === TEAM_EVENT && TEAM || isDoubles && PAIR || INDIVIDUAL;
   const entryStatusMap = Object.assign(
     {},
-    ...(consideredEntries || event.entries || []).map((entry) => ({
+    ...(consideredEntries ?? event.entries ?? []).map((entry) => ({
       [entry.participantId]: entry.entryStatus
     }))
   );
@@ -21427,9 +21483,14 @@ function checkValidEntries({
     const entryStatus = entryStatusMap[participant.participantId];
     const ungroupedParticipant = eventType && [TypeEnum.Doubles, TypeEnum.Team].includes(eventType) && participant.participantType === INDIVIDUAL && (isUngrouped(entryStatus) || entryStatus === WITHDRAWN);
     const mismatch = participant.participantType !== participantType && !ungroupedParticipant;
+    const pairGender = !mismatch && isDoubles && unique(
+      participant?.individualParticipantIds?.map((id) => participantMap?.[id]?.participant?.person?.sex).filter(Boolean) ?? []
+    );
+    const validPairGender = !eventGender || !pairGender?.length || GenderEnum.Any === eventGender || [GenderEnum.Male, GenderEnum.Female].includes(eventGender) && pairGender[0] === eventGender || GenderEnum.Mixed === eventGender && (pairGender.length == 1 && participant.individualParticipantIds?.length === 1 || pairGender.length === 2);
     const personGender = participant?.person?.sex;
-    const wrongGender = enforceGender && eventGender && eventType === TypeEnum.Singles && [GenderEnum.Male, GenderEnum.Female].includes(eventGender) && personGender !== eventGender;
-    return mismatch || wrongGender;
+    const validPersonGender = !participant?.person || !eventGender || [GenderEnum.Any, GenderEnum.Mixed].includes(eventGender) || [GenderEnum.Male, GenderEnum.Female].includes(eventGender) && personGender === eventGender;
+    const validGender = !genderEnforced || validPairGender && validPersonGender;
+    return mismatch || !validGender;
   });
   if (invalidEntries.length) {
     const invalidParticipantIds = invalidEntries.map(
@@ -21437,7 +21498,7 @@ function checkValidEntries({
     );
     return { error: INVALID_ENTRIES, invalidParticipantIds };
   }
-  return { ...SUCCESS };
+  return { ...SUCCESS, valid: true };
 }
 
 function getValidStage({ stage, drawDefinition }) {
@@ -23321,7 +23382,7 @@ function generateDrawDefinition(params) {
   }).appliedPolicies ?? {};
   const drawTypeCoercion = params.drawTypeCoercion ?? appliedPolicies?.[POLICY_TYPE_DRAWS]?.drawTypeCoercion ?? true;
   const drawType = drawTypeCoercion && params.drawSize === 2 && DrawTypeEnum.SingleElimination || params.drawType || DrawTypeEnum.SingleElimination;
-  const { participants } = getParticipants({
+  const { participants, participantMap } = getParticipants({
     withIndividualParticipants: true,
     tournamentRecord
   });
@@ -23340,6 +23401,8 @@ function generateDrawDefinition(params) {
   const consideredEntries = (qualifyingOnly && [] || drawEntries || (considerEventEntries ? eventEntries : [])).filter(({ entryStage }) => !entryStage || entryStage === MAIN);
   const validEntriesResult = event && participants && checkValidEntries({
     consideredEntries,
+    appliedPolicies,
+    participantMap,
     enforceGender,
     participants,
     event