tods-competition-factory 1.7.7 → 1.7.9

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,
@@ -926,93 +934,6 @@ function getTopics() {
   return _globalStateProvider.getTopics();
 }
 
-function isObject(obj) {
-  return typeof obj === "object";
-}
-const extractAttributes = (atz) => (o) => !atz || typeof o !== "object" ? void 0 : Array.isArray(atz) && atz.map((a) => ({ [a]: o[a] })) || typeof atz === "object" && Object.keys(atz).map((key) => ({ [key]: o[key] })) || typeof atz === "string" && getAttr(o, atz);
-function getAttr(o, attr) {
-  const attrs = attr.split(".");
-  for (const a of attrs) {
-    o = o?.[a];
-    if (!o)
-      return;
-  }
-  return o;
-}
-function definedAttributes(obj, ignoreFalse, ignoreEmptyArrays, shallow) {
-  if (typeof obj !== "object" || obj === null)
-    return obj;
-  const deepCopy = deepCopyEnabled();
-  if (!deepCopy?.enabled)
-    shallow = true;
-  const ignoreValues = ["", void 0, null];
-  if (ignoreFalse)
-    ignoreValues.push(false);
-  const definedKeys = Object.keys(obj).filter(
-    (key) => !ignoreValues.includes(obj[key]) && (!ignoreEmptyArrays || (Array.isArray(obj[key]) ? obj[key].length : true))
-  );
-  return Object.assign(
-    {},
-    ...definedKeys.map((key) => {
-      return Array.isArray(obj[key]) ? {
-        [key]: shallow ? obj[key] : obj[key].map((m) => definedAttributes(m))
-      } : { [key]: shallow ? obj[key] : definedAttributes(obj[key]) };
-    })
-  );
-}
-
-function attributeFilter(params) {
-  if (params === null)
-    return {};
-  const { source, template } = params || {};
-  if (!template)
-    return source;
-  const target = {};
-  attributeCopy(source, template, target);
-  return target;
-  function attributeCopy(valuesObject, templateObject, outputObject) {
-    if (!valuesObject || !templateObject)
-      return void 0;
-    const vKeys = Object.keys(valuesObject);
-    const oKeys = Object.keys(templateObject);
-    const orMap = Object.assign(
-      {},
-      ...oKeys.filter((key) => key.indexOf("||")).map((key) => key.split("||").map((or) => ({ [or]: key }))).flat()
-    );
-    const allKeys = oKeys.concat(...Object.keys(orMap));
-    const wildcard = allKeys.includes("*");
-    for (const vKey of vKeys) {
-      if (allKeys.indexOf(vKey) >= 0 || wildcard) {
-        const templateKey = orMap[vKey] || vKey;
-        const tobj = templateObject[templateKey] || wildcard;
-        const vobj = valuesObject[vKey];
-        if (typeof tobj === "object" && typeof vobj !== "function" && !Array.isArray(tobj)) {
-          if (Array.isArray(vobj)) {
-            const mappedElements = vobj.map((arrayMember) => {
-              const target2 = {};
-              const result = attributeCopy(arrayMember, tobj, target2);
-              return result !== false ? target2 : void 0;
-            }).filter(Boolean);
-            outputObject[vKey] = mappedElements;
-          } else if (vobj) {
-            outputObject[vKey] = {};
-            attributeCopy(vobj, tobj, outputObject[vKey]);
-          }
-        } else {
-          const value = valuesObject[vKey];
-          const exclude = Array.isArray(tobj) && !tobj.includes(value);
-          if (exclude)
-            return false;
-          if (templateObject[vKey] || wildcard && templateObject[vKey] !== false) {
-            outputObject[vKey] = value;
-          }
-        }
-      }
-    }
-    return void 0;
-  }
-}
-
 const validTimeString = /^((0[\d]|1[\d]|2[0-3]):[0-5][\d](:[0-5][\d])?)([.,][0-9]{3})?$/;
 const dateValidation = /^([\d]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][\d]|3[0-1]))([ T](0[\d]|1[\d]|2[0-3]):[0-5][\d](:[0-5][\d])?)?([.,][\d]{3})?Z?$/;
 
@@ -1195,6 +1116,147 @@ function extensionsToAttributes(extensions) {
   }).filter(Boolean);
 }
 
+function getAccessorValue({ element, accessor }) {
+  if (typeof accessor !== "string")
+    return { values: [] };
+  const targetElement = makeDeepCopy(element);
+  const attributes = accessor.split(".");
+  const values = [];
+  let value;
+  processKeys({ targetElement, attributes });
+  const result = { value };
+  if (values.length)
+    result.values = values;
+  return result;
+  function processKeys({
+    targetElement: targetElement2,
+    attributes: attributes2 = [],
+    significantCharacters
+  }) {
+    for (const [index, attribute] of attributes2.entries()) {
+      if (targetElement2?.[attribute]) {
+        const remainingKeys = attributes2.slice(index + 1);
+        if (!remainingKeys.length) {
+          if (!value)
+            value = targetElement2[attribute];
+          if (!values.includes(targetElement2[attribute])) {
+            values.push(targetElement2[attribute]);
+          }
+        } else if (Array.isArray(targetElement2[attribute])) {
+          const values2 = targetElement2[attribute];
+          values2.forEach(
+            (nestedTarget) => processKeys({
+              targetElement: nestedTarget,
+              attributes: remainingKeys
+            })
+          );
+        } else {
+          targetElement2 = targetElement2[attribute];
+          checkValue({ targetElement: targetElement2, index });
+        }
+      }
+    }
+    function checkValue({ targetElement: targetElement3, index }) {
+      if (targetElement3 && index === attributes2.length - 1 && ["string", "number"].includes(typeof targetElement3)) {
+        const extractedValue = significantCharacters ? targetElement3.slice(0, significantCharacters) : targetElement3;
+        if (value) {
+          if (!values.includes(extractedValue)) {
+            values.push(extractedValue);
+          }
+        } else {
+          value = extractedValue;
+          values.push(extractedValue);
+        }
+      }
+    }
+  }
+}
+
+function isString(obj) {
+  return typeof obj === "string";
+}
+function isObject(obj) {
+  return typeof obj === "object";
+}
+const extractAttributes = (accessor) => (element) => !accessor || typeof element !== "object" ? void 0 : Array.isArray(accessor) && accessor.map((a) => ({
+  [a]: getAccessorValue({ element, accessor: a })?.value
+})) || typeof accessor === "object" && Object.keys(accessor).map((key) => ({
+  [key]: getAccessorValue({ element, accessor: key })?.value
+})) || (typeof accessor === "string" && getAccessorValue({ element, accessor }))?.value;
+function definedAttributes(obj, ignoreFalse, ignoreEmptyArrays, shallow) {
+  if (typeof obj !== "object" || obj === null)
+    return obj;
+  const deepCopy = deepCopyEnabled();
+  if (!deepCopy?.enabled)
+    shallow = true;
+  const ignoreValues = ["", void 0, null];
+  if (ignoreFalse)
+    ignoreValues.push(false);
+  const definedKeys = Object.keys(obj).filter(
+    (key) => !ignoreValues.includes(obj[key]) && (!ignoreEmptyArrays || (Array.isArray(obj[key]) ? obj[key].length : true))
+  );
+  return Object.assign(
+    {},
+    ...definedKeys.map((key) => {
+      return Array.isArray(obj[key]) ? {
+        [key]: shallow ? obj[key] : obj[key].map((m) => definedAttributes(m))
+      } : { [key]: shallow ? obj[key] : definedAttributes(obj[key]) };
+    })
+  );
+}
+
+function attributeFilter(params) {
+  if (params === null)
+    return {};
+  const { source, template } = params || {};
+  if (!template)
+    return source;
+  const target = {};
+  attributeCopy(source, template, target);
+  return target;
+  function attributeCopy(valuesObject, templateObject, outputObject) {
+    if (!valuesObject || !templateObject)
+      return void 0;
+    const vKeys = Object.keys(valuesObject);
+    const oKeys = Object.keys(templateObject);
+    const orMap = Object.assign(
+      {},
+      ...oKeys.filter((key) => key.indexOf("||")).map((key) => key.split("||").map((or) => ({ [or]: key }))).flat()
+    );
+    const allKeys = oKeys.concat(...Object.keys(orMap));
+    const wildcard = allKeys.includes("*");
+    for (const vKey of vKeys) {
+      if (allKeys.indexOf(vKey) >= 0 || wildcard) {
+        const templateKey = orMap[vKey] || vKey;
+        const tobj = templateObject[templateKey] || wildcard;
+        const vobj = valuesObject[vKey];
+        if (typeof tobj === "object" && typeof vobj !== "function" && !Array.isArray(tobj)) {
+          if (Array.isArray(vobj)) {
+            const mappedElements = vobj.map((arrayMember) => {
+              const target2 = {};
+              const result = attributeCopy(arrayMember, tobj, target2);
+              return result !== false ? target2 : void 0;
+            }).filter(Boolean);
+            outputObject[vKey] = mappedElements;
+          } else if (vobj) {
+            outputObject[vKey] = {};
+            attributeCopy(vobj, tobj, outputObject[vKey]);
+          }
+        } else {
+          const value = valuesObject[vKey];
+          const exclude = Array.isArray(tobj) && !tobj.includes(value);
+          if (exclude)
+            return false;
+          if (templateObject[vKey] || wildcard && templateObject[vKey] !== false) {
+            outputObject[vKey] = value;
+          }
+        }
+      }
+    }
+    return void 0;
+  }
+}
+
 function numericSort(a, b) {
   return a - b;
 }
@@ -4256,7 +4318,7 @@ function isAdHoc({ drawDefinition, structure }) {
   const hasDrawPosition = matchUps?.find(
     (matchUp) => matchUp?.drawPositions?.length
   );
-  return !structure?.structures && !(drawDefinition?.drawType && drawDefinition.drawType !== AD_HOC) && !hasRoundPosition && !hasDrawPosition;
+  return !structure?.structures && structure?.stage !== VOLUNTARY_CONSOLATION && !(drawDefinition?.drawType && drawDefinition.drawType !== AD_HOC) && !hasRoundPosition && !hasDrawPosition;
 }
 
 const POLICY_ROUND_NAMING_DEFAULT = {
@@ -4910,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,
@@ -5022,7 +5093,7 @@ function groupRounds({ groupSize, drawPositionOffset }) {
 }
 
 function generateRoundRobin({
-  structureName = MAIN,
+  structureName = constantToString(MAIN),
   stageSequence = 1,
   structureOptions,
   appliedPolicies,
@@ -14004,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,
@@ -14022,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,
@@ -14100,8 +14172,9 @@ function feedInLinks({
 
 function generateCurtisConsolation(params) {
   const {
+    structureName = constantToString(MAIN),
+    playoffStructureNameBase,
     finishingPositionOffset,
-    structureName = MAIN,
     stageSequence = 1,
     structureNameMap,
     staggeredEntry,
@@ -14139,6 +14212,7 @@ function generateCurtisConsolation(params) {
       const { consolationStructure } = consolationFeedStructure({
         idPrefix: idPrefix && `${idPrefix}-c${index}`,
         structureId: uuids?.pop(),
+        playoffStructureNameBase,
         structureNameMap,
         stageSequence: stageSequence2,
         roundOffset,
@@ -14167,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 = {
@@ -14194,6 +14271,7 @@ function generateCurtisConsolation(params) {
   return { structures, links, ...SUCCESS };
 }
 function consolationFeedStructure({
+  playoffStructureNameBase,
   stageSequence = 1,
   structureNameMap,
   roundOffset = 0,
@@ -14216,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,
@@ -14230,7 +14309,6 @@ function consolationFeedStructure({
 }
 
 function generatePlayoffStructures(params) {
-  let { matchUpType } = params;
   const {
     finishingPositionOffset = 0,
     addNameBaseToAttributeName,
@@ -14260,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}`;
@@ -14310,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,
@@ -14398,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,
@@ -14423,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
@@ -14500,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,
@@ -17351,8 +17438,11 @@ function generateAndPopulatePlayoffStructures(params) {
     structureId: sourceStructureId,
     addNameBaseToAttributeName,
     playoffStructureNameBase,
+    finishingPositionNaming,
+    finishingPositionLimit,
     playoffAttributes,
     playoffPositions,
+    roundOffsetLimit,
     tournamentRecord,
     exitProfileLimit,
     roundProfiles,
@@ -17457,7 +17547,10 @@ function generateAndPopulatePlayoffStructures(params) {
       drawSize,
       idPrefix,
       isMock,
-      uuids
+      uuids,
+      finishingPositionNaming,
+      finishingPositionLimit,
+      roundOffsetLimit
     });
     if (result.error)
       return decorateResult({ result, stack });
@@ -17731,56 +17824,6 @@ function participantScheduledMatchUps({
   return { scheduledMatchUps };
 }
 
-function getAccessorValue({ element, accessor }) {
-  if (typeof accessor !== "string")
-    return { values: [] };
-  const targetElement = makeDeepCopy(element);
-  const attributes = accessor.split(".");
-  const values = [];
-  let value;
-  processKeys({ targetElement, attributes });
-  const result = { value };
-  if (values.length)
-    result.values = values;
-  return result;
-  function processKeys({
-    targetElement: targetElement2,
-    attributes: attributes2 = [],
-    significantCharacters
-  }) {
-    for (const [index, attribute] of attributes2.entries()) {
-      if (targetElement2?.[attribute]) {
-        if (Array.isArray(targetElement2[attribute])) {
-          const values2 = targetElement2[attribute];
-          const remainingKeys = attributes2.slice(index);
-          values2.forEach(
-            (nestedTarget) => processKeys({
-              targetElement: nestedTarget,
-              attributes: remainingKeys
-            })
-          );
-        } else {
-          targetElement2 = targetElement2[attribute];
-          checkValue({ targetElement: targetElement2, index });
-        }
-      }
-    }
-    function checkValue({ targetElement: targetElement3, index }) {
-      if (targetElement3 && index === attributes2.length - 1 && ["string", "number"].includes(typeof targetElement3)) {
-        const extractedValue = significantCharacters ? targetElement3.slice(0, significantCharacters) : targetElement3;
-        if (value) {
-          if (!values.includes(extractedValue)) {
-            values.push(extractedValue);
-          }
-        } else {
-          value = extractedValue;
-          values.push(extractedValue);
-        }
-      }
-    }
-  }
-}
-
 function participantScaleItem({
   requireTimeStamp,
   scaleAttributes,
@@ -19128,13 +19171,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({
@@ -19252,7 +19299,7 @@ function generateDoubleElimination({
     isMock
   });
   const mainStructure = structureTemplate({
-    structureName: structureName || MAIN,
+    structureName: structureName || constantToString(MAIN),
     structureId: uuids?.pop(),
     stageSequence: 1,
     stage: MAIN,
@@ -19271,9 +19318,9 @@ function generateDoubleElimination({
     uuids
   });
   const consolationStructure = structureTemplate({
+    structureName: constantToString(BACKDRAW),
     matchUps: consolationMatchUps,
     structureId: uuids?.pop(),
-    structureName: BACKDRAW,
     stage: CONSOLATION,
     stageSequence: 2,
     matchUpType
@@ -19286,9 +19333,9 @@ function generateDoubleElimination({
     isMock
   });
   const deciderStructure = structureTemplate({
+    structureName: constantToString(DECIDER),
     matchUps: deciderMatchUps,
     structureId: uuids?.pop(),
-    structureName: DECIDER,
     stageSequence: 3,
     stage: PLAY_OFF,
     matchUpType
@@ -19410,11 +19457,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,
@@ -19425,8 +19473,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: [],
@@ -19438,8 +19486,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,
@@ -19465,8 +19513,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,
@@ -19528,9 +19576,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,
@@ -19538,14 +19586,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,
@@ -23267,7 +23315,7 @@ function generateDrawDefinition(params) {
     }
   } else if (structureId && generateQualifyingPlaceholder) {
     const qualifyingStructure = structureTemplate({
-      structureName: QUALIFYING,
+      structureName: constantToString(QUALIFYING),
       stage: QUALIFYING
     });
     const { link } = generateQualifyingLink({