tods-competition-factory 1.8.19 → 1.8.21

package/dist/forge/query.d.ts

@@ -1825,6 +1825,8 @@ declare function generateSeedingScaleItems({ scaleAttributes, scaledEntries, sta
 };
 
 type MatchUpActionsArgs$1 = TournamentRecordsArgs & {
+    policyDefinitions?: PolicyDefinitions;
+    enforceGender?: boolean;
     participantId: string;
     tournamentId: string;
     sideNumber?: number;
@@ -1948,13 +1950,14 @@ type MatchUpActionsArgs = {
     policyDefinitions?: PolicyDefinitions;
     drawDefinition?: DrawDefinition;
     tournamentRecord: Tournament;
+    enforceGender?: boolean;
     participantId?: string;
     sideNumber?: number;
     matchUpId: string;
     drawId?: string;
     event?: Event;
 };
-declare function matchUpActions({ policyDefinitions, tournamentRecord, drawDefinition, participantId, sideNumber, matchUpId, drawId, event, }: MatchUpActionsArgs): (ResultType & {
+declare function matchUpActions({ policyDefinitions, tournamentRecord, drawDefinition, enforceGender, participantId, sideNumber, matchUpId, drawId, event, }: MatchUpActionsArgs): (ResultType & {
     structureIsComplete?: boolean | undefined;
     isDoubleExit?: boolean | undefined;
     isByeMatchUp?: boolean | undefined;
@@ -2040,11 +2043,12 @@ declare function getOrderedDrawPositions({ drawPositions, roundProfile, roundNum
 };
 
 type GetRoundContextProfileArgs = {
+    drawDefinition?: DrawDefinition;
     matchUps: HydratedMatchUp[];
     roundNamingPolicy: any;
     structure: Structure;
 };
-declare function getRoundContextProfile({ roundNamingPolicy, structure, matchUps, }: GetRoundContextProfileArgs): ResultType & {
+declare function getRoundContextProfile({ roundNamingPolicy, drawDefinition, structure, matchUps, }: GetRoundContextProfileArgs): ResultType & {
     roundNamingProfile?: {
         [key: string]: {
             roundName: string;
@@ -2074,6 +2078,7 @@ declare function getParticipantScaleItem({ tournamentRecords, policyDefinitions,
 };
 
 type PositionActionsArgs = {
+    restrictAdHocRoundParticipants?: boolean;
     policyDefinitions?: PolicyDefinitions;
     provisionalPositioning?: boolean;
     returnParticipants?: boolean;
@@ -2113,11 +2118,11 @@ type GetRoundMatchUpsArgs = {
     interpolate?: boolean;
 };
 type RoundMatchUpsResult = {
-    roundsNotPowerOf2?: boolean;
     roundMatchUps?: HydratedMatchUp[];
     hasNoRoundPositions?: boolean;
-    roundProfile?: RoundProfile;
+    roundsNotPowerOf2?: boolean;
     maxMatchUpsCount?: number;
+    roundProfile?: RoundProfile;
     roundNumbers?: number[];
     error?: ErrorType;
 };

package/dist/forge/query.mjs

@@ -6763,6 +6763,9 @@ const POLICY_ROUND_NAMING_DEFAULT = {
     namingConventions: {
       round: "Round"
     },
+    qualifyingFinishMap: {
+      1: "Final"
+    },
     abbreviatedRoundNamingMap: {
       // key is matchUpsCount for the round
       1: "F",
@@ -6776,7 +6779,8 @@ const POLICY_ROUND_NAMING_DEFAULT = {
     },
     affixes: {
       roundNumber: "R",
-      preFeedRound: "Q"
+      preFeedRound: "Q",
+      preQualifying: "P"
     },
     stageConstants: {
       [MAIN]: "",
@@ -6789,6 +6793,7 @@ const POLICY_ROUND_NAMING_DEFAULT = {
 
 function getRoundContextProfile({
   roundNamingPolicy,
+  drawDefinition,
   structure,
   matchUps
 }) {
@@ -6799,21 +6804,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 } };
       })
@@ -6826,15 +6841,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,
@@ -7008,6 +7023,7 @@ function getAllStructureMatchUps({
   const roundNamingPolicy = appliedPolicies?.[POLICY_TYPE_ROUND_NAMING];
   const result = getRoundContextProfile({
     roundNamingPolicy,
+    drawDefinition,
     structure,
     matchUps
   });
@@ -9466,6 +9482,7 @@ function matchUpActions$2({
   inContextDrawMatchUps,
   tournamentRecord,
   drawDefinition,
+  enforceGender,
   participantId,
   matchUpsMap,
   sideNumber,
@@ -9497,8 +9514,8 @@ function matchUpActions$2({
     event
   }).appliedPolicies ?? {};
   Object.assign(appliedPolicies, specifiedPolicyDefinitions ?? {});
-  const isAdHocMatchUp = isAdHoc({ drawDefinition, structure });
   const matchUpActionsPolicy = appliedPolicies?.[POLICY_TYPE_MATCHUP_ACTIONS] ?? POLICY_MATCHUP_ACTIONS_DEFAULT[POLICY_TYPE_MATCHUP_ACTIONS];
+  const isAdHocMatchUp = isAdHoc({ drawDefinition, structure });
   const { enabledStructures } = getEnabledStructures({
     actionType: MATCHUP_ACTION,
     appliedPolicies,
@@ -9712,7 +9729,8 @@ function matchUpActions$2({
     );
     const assignedGender = inContextMatchUp.gender === MIXED && inContextMatchUp.sideNumber && inContextMatchUp.sides?.filter((side2) => side2.particiapntId).length === 1 && firstFoundSide?.participant?.person?.sex;
     const matchUpType = inContextMatchUp.matchUpType;
-    const gender = matchUpActionsPolicy?.participants?.enforceGender ? inContextMatchUp.gender : void 0;
+    const genderEnforced = (enforceGender ?? matchUpActionsPolicy?.participants?.enforceGender) !== false;
+    const gender = genderEnforced ? inContextMatchUp.gender : void 0;
     const allParticipants = inContextMatchUp.sides?.flatMap(
       (side2) => side2.participant?.individualParticipants || side2.participant
     ).filter(Boolean);
@@ -9842,6 +9860,7 @@ function matchUpActions$1({
   policyDefinitions,
   tournamentRecord,
   drawDefinition,
+  enforceGender,
   participantId,
   sideNumber,
   matchUpId,
@@ -9876,6 +9895,7 @@ function matchUpActions$1({
       tournamentParticipants: tournamentRecord.participants,
       policyDefinitions,
       drawDefinition,
+      enforceGender,
       participantId,
       sideNumber,
       matchUpId,
@@ -9889,6 +9909,8 @@ function matchUpActions$1({
 function matchUpActions(params) {
   const {
     tournamentRecords,
+    policyDefinitions,
+    enforceGender,
     participantId,
     tournamentId,
     sideNumber,
@@ -9910,7 +9932,9 @@ function matchUpActions(params) {
     return result;
   return matchUpActions$1({
     drawDefinition: result.drawDefinition,
+    policyDefinitions,
     tournamentRecord,
+    enforceGender,
     participantId,
     sideNumber,
     matchUpId,