tods-competition-factory 1.6.27 → 1.6.29

package/README.md

@@ -1,7 +1,7 @@
-[![NPM](https://img.shields.io/npm/v/tods-competition-factory)](https://www.npmjs.com/package/tods-competition-factory)
-
 # Competition Factory
 
+[![NPM](https://img.shields.io/npm/v/tods-competition-factory)](https://www.npmjs.com/package/tods-competition-factory)
+
 [Online Documentation with examples](https://courthive.github.io/tods-competition-factory/)
 
 ## Tournament Business Rules
@@ -39,7 +39,7 @@ By default a deep copy of documents are made as they are loaded into each state
 ## Other Utilities
 
 1. [**mocksEngine**](./overview/mocks-engine-overview) - generates complete tournament objects, or tournamentRecords, as well as mock persons, participants and matchUp outcomes.
-   It is used extensively in the ~1800 tests that are run against the factory methods before every package release.
+   It is used extensively in the ~1850 tests that are run against the factory methods before every package release.
 2. [**scoreGovernor**](./scoreGovernor) - is a collection of scoring related utilities which provide analysis/validation or generate values, but do not make any mutations.
 3. [**matchUpFormatCode**](./codes/matchup-format) - is an ITF matchUp format code parser, stringifier, and validator.
 4. [**ageCategoryCode**](./codes/age-category) - is an ITF ageCategoryCode parser.

package/dist/forge/generate.d.ts

@@ -1458,9 +1458,10 @@ type GenerateDrawDefinitionArgs = {
     considerEventEntries?: boolean;
     hydrateCollections?: boolean;
     tournamentRecord: Tournament;
-    drawMatic?: DrawMaticArgs;
+    drawTypeCoercion?: boolean;
     ignoreStageSpace?: boolean;
     qualifyingProfiles?: any[];
+    drawMatic?: DrawMaticArgs;
     qualifyingOnly?: boolean;
     drawType?: DrawTypeEnum;
     enforceGender?: boolean;

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";
@@ -14457,9 +14458,9 @@ function processPlayoffGroups({
   for (const playoffGroup of playoffGroups) {
     const finishingPositions = playoffGroup.finishingPositions;
     const positionsPlayedOff = positionRangeMap && finishingPositions.map((p) => positionRangeMap[p]?.finishingPositions).flat();
-    const playoffDrawType = playoffGroup.drawType || SINGLE_ELIMINATION;
     const participantsInDraw = groupCount * finishingPositions.length;
     const drawSize = nextPowerOf2(participantsInDraw);
+    const playoffDrawType = drawSize === 2 && SINGLE_ELIMINATION || playoffGroup.drawType || SINGLE_ELIMINATION;
     if (positionsPlayedOff) {
       finishingPositionOffset = Math.min(...positionsPlayedOff) - 1;
     }
@@ -20157,9 +20158,9 @@ function generateQualifyingStructures({
 function generateDrawStructuresAndLinks(params) {
   const {
     enforceMinimumDrawSize = true,
-    overwriteExisting,
-    drawTypeCoercion,
+    drawTypeCoercion = true,
     // coerce to SINGLE_ELIMINATION for drawSize: 2
+    overwriteExisting,
     appliedPolicies,
     staggeredEntry,
     // optional - specifies main structure FEED_IN for drawTypes CURTIS_CONSOLATION, FEED_IN_CHAMPIONSHIPS, FMLC
@@ -20170,7 +20171,7 @@ function generateDrawStructuresAndLinks(params) {
     uuids
   } = params || {};
   const stack = "generateDrawStructuresAndLinks";
-  let drawType = params.drawType ?? SINGLE_ELIMINATION;
+  let drawType = drawTypeCoercion && params.drawSize === 2 && DrawTypeEnum.SingleElimination || params.drawType || DrawTypeEnum.SingleElimination;
   const structures = [], links = [];
   const matchUpType = params?.matchUpType ?? SINGLES$1;
   const existingQualifyingStructures = drawDefinition?.structures?.filter(
@@ -20859,9 +20860,12 @@ function isUngrouped(entryStatus) {
 
 function checkValidEntries({
   enforceGender = true,
+  consideredEntries,
+  tournamentRecord,
   participants,
   event
 }) {
+  participants = participants || tournamentRecord?.participants;
   if (!participants)
     return { error: MISSING_PARTICIPANTS };
   if (!Array.isArray(participants))
@@ -20872,7 +20876,7 @@ function checkValidEntries({
   const participantType = eventType === TEAM_EVENT && TEAM || eventType === DOUBLES_EVENT && PAIR || INDIVIDUAL;
   const entryStatusMap = Object.assign(
     {},
-    ...(event.entries || []).map((entry) => ({
+    ...(consideredEntries || event.entries || []).map((entry) => ({
       [entry.participantId]: entry.entryStatus
     }))
   );
@@ -22646,9 +22650,9 @@ const POLICY_SEEDING_USTA = {
 function generateDrawDefinition(params) {
   const stack = "generateDrawDefinition";
   const {
-    drawType = DrawTypeEnum.SingleElimination,
     considerEventEntries = true,
     // in the absence of drawSize and drawEntries, look to event.entries
+    drawTypeCoercion = true,
     ignoreAllowedDrawTypes,
     voluntaryConsolation,
     hydrateCollections,
@@ -22656,20 +22660,22 @@ function generateDrawDefinition(params) {
     ignoreStageSpace,
     tournamentRecord,
     qualifyingOnly,
-    enforceGender,
     tieFormatName,
     drawEntries,
     addToEvent,
     placeByes,
     event
   } = params;
+  const drawType = drawTypeCoercion && params.drawSize === 2 && DrawTypeEnum.SingleElimination || params.drawType || DrawTypeEnum.SingleElimination;
   const { tournamentParticipants: participants } = getTournamentParticipants({
     tournamentRecord,
     inContext: true
   });
-  const validEntriesResult = event && participants && checkValidEntries({ event, participants, enforceGender });
-  if (validEntriesResult?.error)
-    return decorateResult({ result: validEntriesResult, stack });
+  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 allowedDrawTypes = !ignoreAllowedDrawTypes && tournamentRecord && getAllowedDrawTypes({
     tournamentRecord,
     categoryType: event?.category?.categoryType,
@@ -22682,6 +22688,14 @@ function generateDrawDefinition(params) {
     (entry) => entry.entryStatus && [...STRUCTURE_ENTERED_TYPES, QUALIFIER].includes(entry.entryStatus)
   ) ?? [];
   const consideredEntries = (qualifyingOnly && [] || drawEntries || (considerEventEntries ? eventEntries : [])).filter(({ entryStage }) => !entryStage || entryStage === MAIN);
+  const validEntriesResult = event && participants && checkValidEntries({
+    consideredEntries,
+    enforceGender,
+    participants,
+    event
+  });
+  if (validEntriesResult?.error)
+    return decorateResult({ result: validEntriesResult, stack });
   const derivedDrawSize = !params.drawSize && consideredEntries.length && ![
     AD_HOC,
     DOUBLE_ELIMINATION,
@@ -22763,10 +22777,6 @@ function generateDrawDefinition(params) {
         drawDefinition.matchUpType = matchUpType;
     }
   }
-  const appliedPolicies = getAppliedPolicies({
-    tournamentRecord,
-    event
-  }).appliedPolicies ?? {};
   if (policyDefinitions) {
     if (typeof policyDefinitions !== "object") {
       return decorateResult({