tods-competition-factory 1.7.8 → 1.7.10

package/dist/forge/generate.d.ts

@@ -1276,6 +1276,28 @@ interface UnifiedVenueID {
     venueId: string;
 }
 
+/**
+ *
+ * @param {object} playoffAttributes - mapping of exitProfile to structure names, e.g. 0-1-1 for SOUTH
+ * @param {string} playoffStructureNameBase - Root word for default playoff naming, e.g. 'Playoff' for 'Playoff 3-4'
+ * @param {string} exitProfile - rounds at which a participant exited each structure, e.g. 0-1-1-1 for losing EAST, WEST, SOUTH
+ * @param {boolean} exitProfileLimit - limit playoff rounds generated by the attributes present in playoffAttributes
+ * @param {number} finishingPositionOffset - amount by which to offset finishingPositions, e.g. 2 for playing off 3-4
+ * @param {number} finishingPositionLimit - highest value of possible finishing Positions to play off
+ * @param {object} finishingPositionNaming - map of { [finishingPositionRange]: customName }
+ * @param {number} roundOffsetLimit - how many rounds to play off (# of additional matchUps per participant)
+ * @param {number} roundOffset - used internally to track generated structures; saved in structure attributes;
+ * @param {number} stageSequence - what sequence within stage structures, e.g. WEST is stageSequence 2 in COMPASS
+ * @param {string} stage - [QUALIFYING, MAIN, CONSOLATION, PLAY-OFF]
+ *
+ */
+type NamingEntry = {
+    [key: string]: {
+        name: string;
+        abbreviation: string;
+    };
+};
+
 type HydratedParticipant = {
     [key: string | number]: any;
 } & Participant;
@@ -1349,13 +1371,16 @@ type RoundProfile = {
 
 type GenerateAndPopulateArgs = {
     addNameBaseToAttributeName?: boolean;
+    finishingPositionNaming?: NamingEntry;
     playoffStructureNameBase?: string;
+    playoffAttributes?: NamingEntry;
+    finishingPositionLimit?: number;
     tournamentRecord?: Tournament;
     drawDefinition: DrawDefinition;
     roundProfiles?: RoundProfile[];
     playoffPositions?: number[];
+    roundOffsetLimit?: number;
     exitProfileLimit?: boolean;
-    playoffAttributes?: any;
     roundNumbers?: number[];
     structureId: string;
     idPrefix?: string;

package/dist/forge/generate.mjs

@@ -503,6 +503,10 @@ const INVALID_STAGE = {
   message: "Invalid stage",
   code: "ERR_INVALID_STAGE"
 };
+const STAGE_SEQUENCE_LIMIT = {
+  message: "stageSequence limit",
+  code: "ERR_LIMIT_STAGE_SEQUENCE"
+};
 const MISSING_POSITION_ASSIGNMENTS = {
   message: "Missing positionAssignments",
   code: "ERR_MISSING_POSITION_ASSIGNMENTS"
@@ -724,6 +728,10 @@ const EXISTING_STAGE = {
   message: "Existing stage",
   code: "ERR_EXISTING_STAGE"
 };
+const EXISTING_STRUCTURE = {
+  message: "Existing structure",
+  code: "ERR_EXISTING_STRUCTURE"
+};
 
 const syncGlobalState = {
   disableNotifications: false,
@@ -1164,6 +1172,9 @@ function getAccessorValue({ element, accessor }) {
   }
 }
 
+function isString(obj) {
+  return typeof obj === "string";
+}
 function isObject(obj) {
   return typeof obj === "object";
 }
@@ -4961,6 +4972,15 @@ function getNumericSeedValue(seedValue) {
   return Infinity;
 }
 
+function capitalizeFirst(str) {
+  return !isString(str) ? str : str.split(" ").map(
+    (name) => name.split("").map((c, i) => i ? c.toLowerCase() : c.toUpperCase()).join("")
+  ).join(" ");
+}
+function constantToString(str) {
+  return !isString(str) ? str : capitalizeFirst(str.replace(/_/g, " "));
+}
+
 const structureTemplate = ({
   finishingPosition = ROUND_OUTCOME,
   qualifyingRoundNumber,
@@ -5073,7 +5093,7 @@ function groupRounds({ groupSize, drawPositionOffset }) {
 }
 
 function generateRoundRobin({
-  structureName = MAIN,
+  structureName = constantToString(MAIN),
   stageSequence = 1,
   structureOptions,
   appliedPolicies,
@@ -14055,8 +14075,8 @@ function firstRoundLoserConsolation(params) {
   };
   const { matchUps } = staggeredEntry ? feedInMatchUps(mainParams) : treeMatchUps(mainParams);
   const mainStructure = structureTemplate({
+    structureName: structureName || constantToString(MAIN),
     structureId: structureId || uuids?.pop(),
-    structureName: structureName || MAIN,
     stageSequence,
     matchUpType,
     matchUps,
@@ -14073,7 +14093,8 @@ function firstRoundLoserConsolation(params) {
       matchUpType,
       isMock
     });
-    const consolationStructureName = params.consolationStructureName || (structureName ? `${structureName} ${CONSOLATION}` : CONSOLATION);
+    const consolation = constantToString(CONSOLATION);
+    const consolationStructureName = params.consolationStructureName || (structureName ? `${structureName} ${consolation}` : consolation);
     const consolationStructure = structureTemplate({
       structureName: consolationStructureName,
       matchUps: consolationMatchUps,
@@ -14151,8 +14172,9 @@ function feedInLinks({
 
 function generateCurtisConsolation(params) {
   const {
+    structureName = constantToString(MAIN),
+    playoffStructureNameBase,
     finishingPositionOffset,
-    structureName = MAIN,
     stageSequence = 1,
     structureNameMap,
     staggeredEntry,
@@ -14190,6 +14212,7 @@ function generateCurtisConsolation(params) {
       const { consolationStructure } = consolationFeedStructure({
         idPrefix: idPrefix && `${idPrefix}-c${index}`,
         structureId: uuids?.pop(),
+        playoffStructureNameBase,
         structureNameMap,
         stageSequence: stageSequence2,
         roundOffset,
@@ -14218,12 +14241,15 @@ function generateCurtisConsolation(params) {
         matchUpType,
         isMock
       });
+      const defaultName = constantToString(PLAY_OFF);
+      const mappedStructureName = structureNameMap?.[defaultName] || defaultName;
+      const structureName2 = playoffStructureNameBase ? `${playoffStructureNameBase} ${mappedStructureName}` : mappedStructureName;
       const playoffStructure = structureTemplate({
-        structureName: structureNameMap?.[PLAY_OFF] || PLAY_OFF,
         structureId: uuids?.pop(),
         matchUps: playoffMatchUps,
         stageSequence: 2,
         stage: PLAY_OFF,
+        structureName: structureName2,
         matchUpType
       });
       const playoffLink = {
@@ -14245,6 +14271,7 @@ function generateCurtisConsolation(params) {
   return { structures, links, ...SUCCESS };
 }
 function consolationFeedStructure({
+  playoffStructureNameBase,
   stageSequence = 1,
   structureNameMap,
   roundOffset = 0,
@@ -14267,8 +14294,9 @@ function consolationFeedStructure({
     isMock,
     uuids
   });
-  const defaultName = `${CONSOLATION} ${index + 1}`;
-  const structureName = structureNameMap?.[defaultName] || defaultName;
+  const defaultName = `${constantToString(CONSOLATION)} ${index + 1}`;
+  const mappedStructureName = structureNameMap?.[defaultName] || defaultName;
+  const structureName = playoffStructureNameBase ? `${playoffStructureNameBase} ${mappedStructureName}` : mappedStructureName;
   const consolationStructure = structureTemplate({
     matchUps: consolationMatchUps,
     stage: CONSOLATION,
@@ -14281,7 +14309,6 @@ function consolationFeedStructure({
 }
 
 function generatePlayoffStructures(params) {
-  let { matchUpType } = params;
   const {
     finishingPositionOffset = 0,
     addNameBaseToAttributeName,
@@ -14311,7 +14338,7 @@ function generatePlayoffStructures(params) {
   const allMatchUps = [];
   const structures = [];
   const links = [];
-  matchUpType = matchUpType || drawDefinition?.matchUpType;
+  const matchUpType = params.matchUpType || drawDefinition?.matchUpType;
   const finishingPositionsFrom = finishingPositionOffset + 1;
   const finishingPositionsTo = finishingPositionOffset + drawSize;
   const finishingPositionRange = `${finishingPositionsFrom}-${finishingPositionsTo}`;
@@ -14361,7 +14388,7 @@ function generatePlayoffStructures(params) {
     if (playoffDrawPositions < 2)
       return;
     const childFinishingPositionOffset = drawSize / Math.pow(2, roundNumber) + finishingPositionOffset;
-    if (childFinishingPositionOffset + 1 > finishingPositionLimit)
+    if (finishingPositionLimit && childFinishingPositionOffset + 1 > finishingPositionLimit)
       return;
     const {
       structures: childStructures,
@@ -14449,8 +14476,8 @@ function feedInChampionship(params) {
   };
   const { matchUps } = staggeredEntry ? feedInMatchUps(mainParams) : treeMatchUps(mainParams);
   const mainStructure = structureTemplate({
+    structureName: structureName || constantToString(MAIN),
     structureId: structureId || uuids?.pop(),
-    structureName: structureName || MAIN,
     stageSequence,
     matchUpType,
     matchUps,
@@ -14474,9 +14501,9 @@ function feedInChampionship(params) {
   });
   if (drawSize > 2) {
     const consolationStructure = structureTemplate({
+      structureName: constantToString(CONSOLATION),
       matchUps: consolationMatchUps,
       structureId: uuids?.pop(),
-      structureName: CONSOLATION,
       stage: CONSOLATION,
       stageSequence: 1,
       matchUpType
@@ -14551,10 +14578,19 @@ function processPlayoffGroups({
     if (positionsPlayedOff) {
       finishingPositionOffset = Math.min(...positionsPlayedOff) - 1;
     }
-    const params = {
+    const playoffGroupParams = {
+      addNameBaseToAttributeName: playoffGroup.addNameBaseToAttributeName,
+      playoffStructureNameBase: playoffGroup.playoffStructureNameBase,
+      finishingPositionNaming: playoffGroup.finishingPositionNaming,
+      finishingPositionLimit: playoffGroup.finishingPositionLimit,
       structureId: playoffGroup.structureId ?? uuids?.pop(),
+      playoffAttributes: playoffGroup.playoffAttributes,
       structureNameMap: playoffGroup.structureNameMap,
       structureName: playoffGroup.structureName,
+      sequenceLimit: playoffGroup.sequenceLimit
+    };
+    const params = {
+      ...playoffGroupParams,
       idPrefix: idPrefix && `${idPrefix}-po`,
       appliedPolicies: policyDefinitions,
       finishingPositionOffset,
@@ -16559,20 +16595,20 @@ function evaluateCollectionResult({
     if (matchUp.winningSide)
       sideWins[matchUp.winningSide - 1] += 1;
   });
-  if (matchUpValue) {
+  if (isConvertableInteger(matchUpValue)) {
     collectionMatchUps.forEach((matchUp) => {
       if (matchUp.winningSide) {
         sideMatchUpValues[matchUp.winningSide - 1] += matchUpValue;
       }
     });
-  } else if (setValue) {
+  } else if (isConvertableInteger(setValue)) {
     collectionMatchUps.forEach((matchUp) => {
       matchUp.score?.sets?.forEach((set) => {
         if (set.winningSide)
           sideMatchUpValues[set.winningSide - 1] += setValue;
       });
     });
-  } else if (scoreValue) {
+  } else if (isConvertableInteger(scoreValue)) {
     collectionMatchUps.forEach((matchUp) => {
       matchUp.score?.sets?.forEach((set) => {
         const {
@@ -16599,15 +16635,17 @@ function evaluateCollectionResult({
           collectionDefinition,
           collectionPosition
         });
-        sideMatchUpValues[matchUp.winningSide - 1] += matchUpValue2;
+        if (isConvertableInteger(matchUpValue2)) {
+          sideMatchUpValues[matchUp.winningSide - 1] += matchUpValue2;
+        }
       }
     });
   }
-  if (collectionValue) {
+  if (isConvertableInteger(collectionValue)) {
     let collectionWinningSide;
     if (winCriteria?.aggregateValue) {
       if (allCollectionMatchUpsCompleted) {
-        if ((matchUpValue || setValue || scoreValue) && sideMatchUpValues[0] !== sideMatchUpValues[1]) {
+        if (isConvertableInteger(matchUpValue || setValue || scoreValue) && sideMatchUpValues[0] !== sideMatchUpValues[1]) {
           collectionWinningSide = sideMatchUpValues[0] > sideMatchUpValues[1] ? 1 : 2;
         } else if (sideWins[0] !== sideWins[1]) {
           collectionWinningSide = sideWins[0] > sideWins[1] ? 1 : 2;
@@ -16643,7 +16681,7 @@ function evaluateCollectionResult({
   }
   if (!belongsToValueGroup) {
     sideCollectionValues.forEach(
-      (sideCollectionValue, i) => sideTieValues[i] += sideCollectionValue
+      (sideCollectionValue, i) => sideTieValues[i] += sideCollectionValue || 0
     );
   } else {
     groupValueGroups[collectionGroupNumber].sideWins[0] += sideWins[0] || 0;
@@ -16668,7 +16706,9 @@ function getGroupValueGroups({
 }) {
   const groupValueGroups = Object.assign(
     {},
-    ...collectionGroups.filter((group) => group?.groupValue && group?.groupNumber).map((group) => ({
+    ...collectionGroups.filter(
+      (group) => isConvertableInteger(group?.groupValue) && group?.groupNumber
+    ).map((group) => ({
       [group.groupNumber]: {
         ...group,
         allGroupMatchUpsCompleted: true,
@@ -16745,11 +16785,11 @@ function generateTieMatchUpScore(params) {
       }, void 0);
     }
     if (groupWinningSide) {
-      sideTieValues[groupWinningSide - 1] += groupValue;
+      sideTieValues[groupWinningSide - 1] += groupValue || 0;
     }
   }
   const sideScores = sideTieValues.map(
-    (sideTieValue, i) => sideTieValue + sideAdjustments[i]
+    (sideTieValue, i) => (sideTieValue || 0) + sideAdjustments[i]
   );
   const set = {
     side1Score: sideScores[0],
@@ -17402,8 +17442,11 @@ function generateAndPopulatePlayoffStructures(params) {
     structureId: sourceStructureId,
     addNameBaseToAttributeName,
     playoffStructureNameBase,
+    finishingPositionNaming,
+    finishingPositionLimit,
     playoffAttributes,
     playoffPositions,
+    roundOffsetLimit,
     tournamentRecord,
     exitProfileLimit,
     roundProfiles,
@@ -17508,7 +17551,10 @@ function generateAndPopulatePlayoffStructures(params) {
       drawSize,
       idPrefix,
       isMock,
-      uuids
+      uuids,
+      finishingPositionNaming,
+      finishingPositionLimit,
+      roundOffsetLimit
     });
     if (result.error)
       return decorateResult({ result, stack });
@@ -19129,13 +19175,17 @@ function createGroupParticipant({
 
 function generateRoundRobinWithPlayOff(params) {
   const { drawDefinition, structureOptions, requireSequential } = params;
-  const mainDrawProperties = { structureName: MAIN, ...params, stage: MAIN };
+  const mainDrawProperties = {
+    structureName: constantToString(MAIN),
+    ...params,
+    stage: MAIN
+  };
   const { structures, groupCount, groupSize } = generateRoundRobin(mainDrawProperties);
   if (groupCount < 1) {
     console.log(INVALID_CONFIGURATION);
   }
   const playoffGroups = structureOptions?.playoffGroups || [
-    { finishingPositions: [1], structureName: PLAY_OFF }
+    { finishingPositions: [1], structureName: constantToString(PLAY_OFF) }
   ];
   const [mainStructure] = structures;
   const { structures: playoffStructures, links } = processPlayoffGroups({
@@ -19253,7 +19303,7 @@ function generateDoubleElimination({
     isMock
   });
   const mainStructure = structureTemplate({
-    structureName: structureName || MAIN,
+    structureName: structureName || constantToString(MAIN),
     structureId: uuids?.pop(),
     stageSequence: 1,
     stage: MAIN,
@@ -19272,9 +19322,9 @@ function generateDoubleElimination({
     uuids
   });
   const consolationStructure = structureTemplate({
+    structureName: constantToString(BACKDRAW),
     matchUps: consolationMatchUps,
     structureId: uuids?.pop(),
-    structureName: BACKDRAW,
     stage: CONSOLATION,
     stageSequence: 2,
     matchUpType
@@ -19287,9 +19337,9 @@ function generateDoubleElimination({
     isMock
   });
   const deciderStructure = structureTemplate({
+    structureName: constantToString(DECIDER),
     matchUps: deciderMatchUps,
     structureId: uuids?.pop(),
-    structureName: DECIDER,
     stageSequence: 3,
     stage: PLAY_OFF,
     matchUpType
@@ -19411,11 +19461,12 @@ function getGenerators(params) {
   const { appliedPolicies } = getAppliedPolicies(params);
   const feedPolicy = params.policyDefinitions?.[POLICY_TYPE_FEED_IN] || appliedPolicies?.[POLICY_TYPE_FEED_IN];
   params.skipRounds = params.skipRounds || drawSize <= 4 && (feedPolicy?.feedMainFinal ? 0 : 1) || 0;
+  const main = constantToString(MAIN);
   const singleElimination = () => {
     const { matchUps } = treeMatchUps(params);
     const structure = structureTemplate({
-      structureName: structureName || MAIN,
       structureId: structureId || uuids?.pop(),
+      structureName: structureName || main,
       stageSequence,
       matchUpType,
       matchUps,
@@ -19426,8 +19477,8 @@ function getGenerators(params) {
   const generators = {
     [AD_HOC]: () => {
       const structure = structureTemplate({
-        structureName: structureName || MAIN,
         structureId: structureId || uuids?.pop(),
+        structureName: structureName || main,
         finishingPosition: WIN_RATIO,
         stageSequence,
         matchUps: [],
@@ -19439,8 +19490,8 @@ function getGenerators(params) {
     [LUCKY_DRAW]: () => {
       const { matchUps } = luckyDraw(params);
       const structure = structureTemplate({
-        structureName: structureName || MAIN,
         structureId: structureId || uuids?.pop(),
+        structureName: structureName || main,
         stageSequence,
         matchUpType,
         matchUps,
@@ -19466,8 +19517,8 @@ function getGenerators(params) {
     [FEED_IN$1]: () => {
       const { matchUps } = feedInMatchUps({ drawSize, uuids, matchUpType });
       const structure = structureTemplate({
-        structureName: structureName || MAIN,
         structureId: structureId || uuids?.pop(),
+        structureName: structureName || main,
         stageSequence,
         matchUpType,
         stage: MAIN,
@@ -19529,9 +19580,9 @@ function generateVoluntaryConsolation$1(params) {
       return result2;
   }
   tieFormat = copyTieFormat(
-    tieFormat || resolveTieFormat({ drawDefinition })?.tieFormat
+    tieFormat ?? resolveTieFormat({ drawDefinition })?.tieFormat
   );
-  matchUpType = matchUpType || drawDefinition.matchUpType || TypeEnum.Singles;
+  matchUpType = matchUpType ?? drawDefinition.matchUpType ?? TypeEnum.Singles;
   const { structures: stageStructures } = getDrawStructures({
     stageSequence: 1,
     drawDefinition,
@@ -19539,14 +19590,14 @@ function generateVoluntaryConsolation$1(params) {
   });
   const structureCount = stageStructures.length;
   if (structureCount > 1)
-    return { error: INVALID_STRUCTURE };
+    return { error: STAGE_SEQUENCE_LIMIT };
   if (stageStructures?.[0]?.matchUps?.length)
-    return { error: INVALID_STRUCTURE };
+    return { error: EXISTING_STRUCTURE };
   const structureId = stageStructures?.[0]?.structureId;
   Object.assign(
     params,
     definedAttributes({
-      structureName: params.structureName || VOLUNTARY_CONSOLATION,
+      structureName: params.structureName ?? constantToString(VOLUNTARY_CONSOLATION),
       structureId,
       matchUpType,
       tieFormat,
@@ -23268,7 +23319,7 @@ function generateDrawDefinition(params) {
     }
   } else if (structureId && generateQualifyingPlaceholder) {
     const qualifyingStructure = structureTemplate({
-      structureName: QUALIFYING,
+      structureName: constantToString(QUALIFYING),
       stage: QUALIFYING
     });
     const { link } = generateQualifyingLink({