tods-competition-factory 1.8.3 → 1.8.5

package/dist/forge/generate.mjs

@@ -319,7 +319,7 @@ function groupConsecutiveNumbers(arr) {
     return result;
   }, []);
 }
-function allNumeric(arr) {
+function allNumeric$1(arr) {
   return arr.reduce((numeric, item) => !isNaN(parseInt(item)) && numeric, true);
 }
 function noNumeric(arr) {
@@ -587,6 +587,10 @@ const MISSING_VALUE = {
   message: "Missing value",
   code: "ERR_MISSING_VALUE"
 };
+const INVALID_DATE = {
+  message: "Invalid Date",
+  code: "ERR_INVALID_DATE"
+};
 const INVALID_PARTICIPANT_ID = {
   message: "Invalid participantId",
   code: "ERR_INVALID_PARTICIPANT_ID"
@@ -703,10 +707,18 @@ const INVALID_CONFIGURATION = {
   message: "Invalid configuration",
   code: "ERR_INVALID_CONFIG"
 };
+const INVALID_COLLECTION_DEFINITION = {
+  message: "Invalid collectionDefinition",
+  code: "ERR_INVALID_COLLECTION_DEFINITION"
+};
 const INVALID_OBJECT = {
   message: "Invalid object",
   code: "ERR_INVALID_OBJECT"
 };
+const INVALID_CATEGORY = {
+  message: "Invalid category",
+  code: "ERR_INVALID_CATEGORY"
+};
 const INVALID_VALUES = {
   message: "Invalid values",
   code: "ERR_INVALID_VALUES"
@@ -933,7 +945,11 @@ function deleteNotice({ key, topic }) {
 function getTopics() {
   return _globalStateProvider.getTopics();
 }
+function getProvider() {
+  return _globalStateProvider;
+}
 
+const validDateString = /^[\d]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][\d]|3[0-1])$/;
 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?$/;
 
@@ -957,6 +973,9 @@ function isDateObject(value) {
     return datePrototype === "[object Date]";
   }
 }
+function isValidDateString(scheduleDate) {
+  return isISODateString(scheduleDate) || validDateString.test(scheduleDate);
+}
 const getUTCdateString = (date) => {
   const dateDate = isDate(date) || isISODateString(date) ? new Date(date) : /* @__PURE__ */ new Date();
   const monthNumber = dateDate.getUTCMonth() + 1;
@@ -1007,6 +1026,11 @@ function extractTime(dateString) {
 function extractDate(dateString) {
   return isISODateString(dateString) || dateValidation.test(dateString) ? dateString.split("T")[0] : void 0;
 }
+function dateStringDaysChange(dateString, daysChange) {
+  const date = new Date(dateString);
+  date.setDate(date.getDate() + daysChange);
+  return extractDate(date.toISOString());
+}
 function splitTime(value) {
   value = typeof value !== "string" ? "00:00" : value;
   const o = {}, time = {};
@@ -1060,6 +1084,13 @@ function sameDay(date1, date2) {
 }
 
 function makeDeepCopy(sourceObject, convertExtensions, internalUse, removeExtensions, iteration = 0) {
+  if (getProvider().makeDeepCopy)
+    return getProvider().makeDeepCopy(
+      sourceObject,
+      convertExtensions,
+      internalUse,
+      removeExtensions
+    );
   const deepCopy = deepCopyEnabled();
   const { stringify, toJSON, ignore, modulate } = deepCopy || {};
   if (!deepCopy?.enabled && !internalUse || typeof sourceObject !== "object" || typeof sourceObject === "function" || sourceObject === null || typeof deepCopy?.threshold === "number" && iteration >= deepCopy.threshold) {
@@ -2757,7 +2788,7 @@ function parse(matchUpFormatCode) {
         setFormat,
         bestOf: 1
       };
-      if (parsedFormat.setFormat)
+      if (setFormat)
         return parsedFormat;
     }
     if (type === SET)
@@ -2767,16 +2798,23 @@ function parse(matchUpFormatCode) {
 }
 function setsMatch(formatstring) {
   const parts = formatstring.split("-");
-  const bestOf = getNumber$1(parts[0].slice(3));
+  const setsCount = getNumber$1(parts[0].slice(3));
+  const bestOf = setsCount === 1 || setsCount % 2 !== 0 ? setsCount : void 0;
+  const exactly = setsCount !== 1 && setsCount % 2 === 0 ? setsCount : void 0;
   const setFormat = parts && parseSetFormat(parts[1]);
   const finalSetFormat = parts && parseSetFormat(parts[2]);
-  const validBestOf = bestOf && bestOf < 6;
+  const timed = setFormat && setFormat.timed || finalSetFormat && finalSetFormat.timed;
+  const validSetsCount = bestOf && bestOf < 6 || timed && exactly;
   const validFinalSet = !parts[2] || finalSetFormat;
   const validSetsFormat = setFormat;
-  const result = { bestOf, setFormat };
+  const result = definedAttributes({
+    setFormat,
+    exactly,
+    bestOf
+  });
   if (finalSetFormat)
     result.finalSetFormat = finalSetFormat;
-  if (validBestOf && validSetsFormat && validFinalSet)
+  if (validSetsCount && validSetsFormat && validFinalSet)
     return result;
 }
 function parseSetFormat(formatstring) {
@@ -3891,10 +3929,10 @@ function getOrderedDrawPositions({
   const pairedDrawPositions = targetRoundProfile?.pairedDrawPositions;
   const displayOrder = pairedDrawPositions?.find(
     (pair) => overlap(pair || [], drawPositions.filter(Boolean))
-  ) || unassignedDrawPositions;
+  ) ?? unassignedDrawPositions;
   const isFeedRound = targetRoundProfile?.feedRound;
-  if (allNumeric(drawPositions)) {
-    const orderedDrawPositions = drawPositions.sort(numericSort);
+  if (allNumeric$1(drawPositions)) {
+    const orderedDrawPositions = [...drawPositions].sort(numericSort);
     return {
       orderedDrawPositions: orderedDrawPositions.length === 2 ? orderedDrawPositions : displayOrder,
       displayOrder: isFeedRound ? orderedDrawPositions : displayOrder
@@ -4617,7 +4655,7 @@ function getAllStructureMatchUps({
     matchUp,
     event: event2
   }) {
-    additionalContext = additionalContext || {};
+    additionalContext = additionalContext ?? {};
     const tieFormat = resolveTieFormat({
       drawDefinition,
       structure,
@@ -4628,7 +4666,7 @@ function getAllStructureMatchUps({
     const collectionDefinition = matchUp.collectionId && collectionDefinitions?.find(
       (definition) => definition.collectionId === matchUp.collectionId
     );
-    const matchUpFormat = matchUp.collectionId ? collectionDefinition?.matchUpFormat : matchUp.matchUpFormat || structure?.matchUpFormat || drawDefinition?.matchUpFormat || event2?.matchUpFormat;
+    const matchUpFormat = matchUp.collectionId ? collectionDefinition?.matchUpFormat : matchUp.matchUpFormat ?? structure?.matchUpFormat ?? drawDefinition?.matchUpFormat ?? event2?.matchUpFormat;
     const matchUpType = matchUp.matchUpType || collectionDefinition?.matchUpType || structure?.matchUpType || drawDefinition?.matchUpType || event2?.eventType !== TEAM$1 && event2?.eventType;
     const matchUpStatus = isCollectionBye ? BYE : matchUp.matchUpStatus;
     const { schedule, endDate } = getMatchUpScheduleDetails({
@@ -4643,7 +4681,7 @@ function getAllStructureMatchUps({
     });
     const drawPositions = tieDrawPositions ?? matchUp.drawPositions ?? [];
     const { collectionPosition, collectionId, roundPosition } = matchUp;
-    const roundNumber = matchUp.roundNumber || additionalContext.roundNumber;
+    const roundNumber = matchUp.roundNumber ?? additionalContext.roundNumber;
     const drawPositionCollectionAssignment = collectionId ? getDrawPositionCollectionAssignment({
       tournamentParticipants,
       positionAssignments,
@@ -4669,7 +4707,7 @@ function getAllStructureMatchUps({
     } : context?.category;
     const processCodes = matchUp.processCodes?.length && matchUp.processCodes || collectionDefinition?.processCodes?.length && collectionDefinition?.processCodes || structure?.processCodes?.length && structure?.processCodes || drawDefinition?.processCodes?.length && drawDefinition?.processCodes || event2?.processCodes?.length && event2?.processCodes || tournamentRecord?.processCodes;
     const competitiveProfile = contextProfile?.withCompetitiveness && getMatchUpCompetitiveProfile({ ...contextContent, matchUp });
-    const finishingPositionRange = matchUp.finishingPositionRange || additionalContext.finishingPositionRange;
+    const finishingPositionRange = matchUp.finishingPositionRange ?? additionalContext.finishingPositionRange;
     const onlyDefined = (obj) => definedAttributes(obj, void 0, true);
     const matchUpWithContext = {
       ...onlyDefined(context),
@@ -4677,7 +4715,7 @@ function getAllStructureMatchUps({
         matchUpFormat: matchUp.matchUpType === TEAM$1 ? void 0 : matchUpFormat,
         tieFormat: matchUp.matchUpType !== TEAM$1 ? void 0 : tieFormat,
         roundOfPlay: stage !== QUALIFYING && isConvertableInteger(initialRoundOfPlay2) && initialRoundOfPlay2 + (roundNumber || 0),
-        endDate: matchUp.endDate || endDate,
+        endDate: matchUp.endDate ?? endDate,
         gender: collectionDefinition?.gender,
         discipline: event2?.discipline,
         category: matchUpCategory,
@@ -4997,7 +5035,7 @@ function getRoundRobinGroupMatchUps({ drawPositions }) {
   return { groupMatchUps, uniqueMatchUpGroupings };
 }
 function drawPositionsHash(drawPositions) {
-  return drawPositions.sort(numericSort).join("|");
+  return [...drawPositions].sort(numericSort).join("|");
 }
 function groupRounds({ groupSize, drawPositionOffset }) {
   const numArr = (count) => [...Array(count)].map((_, i) => i);
@@ -5023,7 +5061,7 @@ function groupRounds({ groupSize, drawPositionOffset }) {
   aRow = [aHead, bUp, ...aRow].filter(Boolean);
   bRow = [...bRow, aDown].filter(Boolean);
   const sum = (x) => x[0].reduce((a, b) => a + b);
-  return rounds.reverse().sort((a, b) => sum(a) - sum(b)).map(
+  return [...rounds].reverse().sort((a, b) => sum(a) - sum(b)).map(
     (round) => round.filter(
       (groupPositions2) => groupPositions2.every((position) => position <= groupSize)
     ).map((groupPositions2) => {
@@ -5035,22 +5073,25 @@ function groupRounds({ groupSize, drawPositionOffset }) {
   );
 }
 
-function generateRoundRobin({
-  structureName = constantToString(MAIN),
-  groupNameBase = "Group",
-  stageSequence = 1,
-  structureOptions,
-  appliedPolicies,
-  seedingProfile,
-  stage = MAIN,
-  matchUpType,
-  roundTarget,
-  structureId,
-  drawSize,
-  idPrefix,
-  isMock,
-  uuids
-}) {
+function generateRoundRobin(params) {
+  const {
+    groupNameBase = "Group",
+    playoffAttributes,
+    stageSequence = 1,
+    structureOptions,
+    appliedPolicies,
+    seedingProfile,
+    stage = MAIN,
+    matchUpType,
+    roundTarget,
+    structureId,
+    groupNames,
+    drawSize,
+    idPrefix,
+    isMock,
+    uuids
+  } = params;
+  const structureName = params.structureName ?? playoffAttributes?.["0"]?.name ?? constantToString(MAIN);
   const { groupCount, groupSize } = deriveGroups({
     structureOptions,
     appliedPolicies,
@@ -5070,12 +5111,13 @@ function generateRoundRobin({
     maxRoundNumber = Math.max(
       ...matchUps.map(({ roundNumber }) => roundNumber)
     );
+    const structureName2 = groupNames?.[structureOrder - 1] ?? `${groupNameBase} ${structureOrder}`;
     return structureTemplate({
-      structureName: `${groupNameBase} ${structureOrder}`,
       structureId: uuids?.pop(),
       structureType: ITEM,
       finishingPosition,
       structureOrder,
+      structureName: structureName2,
       matchUps
     });
   });
@@ -8104,10 +8146,10 @@ function addUpcomingMatchUps({ drawDefinition, inContextDrawMatchUps }) {
     if (structure?.finishingPosition === WIN_RATIO) {
       const { roundNumber } = inContextMatchUp;
       const nextRoundNumber = roundNumber && ensureInt(roundNumber) + 1;
-      const matchUps = structure.matchUps || [];
+      const matchUps = structure.matchUps ?? [];
       const { roundMatchUps } = getRoundMatchUps({ matchUps });
       if (nextRoundNumber && roundMatchUps?.[nextRoundNumber]) {
-        const sidesTo = drawPositions.sort().map((drawPosition, index) => {
+        const sidesTo = [...drawPositions].sort(numericSort).map((drawPosition, index) => {
           const nextRoundMatchUp = roundMatchUps[nextRoundNumber].find(
             (matchUp) => matchUp.drawPositions?.includes(drawPosition)
           );
@@ -14261,7 +14303,7 @@ function generatePlayoffStructures(params) {
   const attributeProfile = playoffAttributes?.[exitProfile];
   const base = playoffStructureNameBase && `${playoffStructureNameBase} ` || "";
   const customNaming = playoffAttributes?.[finishingPositionRange] ?? finishingPositionNaming?.[finishingPositionRange];
-  const structureName = customNaming?.name || attributeProfile?.name && (addNameBaseToAttributeName ? `${base}${attributeProfile?.name}` : attributeProfile.name) || `${base}${finishingPositionRange}`;
+  const structureName = params.structureName || customNaming?.name || attributeProfile?.name && (addNameBaseToAttributeName ? `${base}${attributeProfile?.name}` : attributeProfile.name) || `${base}${finishingPositionRange}`;
   const structureAbbreviation = customNaming?.abbreviation || attributeProfile?.abbreviation;
   const mainParams = {
     idPrefix: idPrefix && `${idPrefix}-${structureName}-RP`,
@@ -14417,12 +14459,14 @@ function feedInChampionship(params) {
     fmlc
   });
   if (drawSize > 2) {
+    const name = playoffAttributes?.["0-1"]?.name ?? constantToString(CONSOLATION);
+    const structureName2 = params.playoffStructureNameBase ? `${params.playoffStructureNameBase} ${name}` : name;
     const consolationStructure = structureTemplate({
-      structureName: playoffAttributes?.["0-1"]?.name ?? constantToString(CONSOLATION),
       matchUps: consolationMatchUps,
       structureId: uuids?.pop(),
       stage: CONSOLATION,
       stageSequence: 1,
+      structureName: structureName2,
       matchUpType
     });
     structures.push(consolationStructure);
@@ -14568,8 +14612,9 @@ function processPlayoffGroups({
     } else if ([COMPASS, OLYMPIC, PLAY_OFF].includes(playoffDrawType)) {
       const params2 = {
         playoffAttributes: playoffGroup.playoffAttributes ?? playoffAttributes,
+        playoffStructureNameBase: playoffGroup.playoffStructureNameBase,
         structureId: playoffGroup.structureId ?? uuids?.pop(),
-        playoffStructureNameBase: structureName,
+        structureName: playoffGroup.structureName,
         idPrefix: idPrefix && `${idPrefix}-po`,
         addNameBaseToAttributeName: true,
         finishingPositionOffset,
@@ -14622,7 +14667,9 @@ function processPlayoffGroups({
     ].includes(playoffDrawType)) {
       const uuidsFMLC = [uuids?.pop(), uuids?.pop()];
       const params2 = {
+        playoffStructureNameBase: playoffGroup.playoffStructureNameBase,
         structureId: playoffGroup.structureId ?? uuids?.pop(),
+        playoffAttributes: playoffGroup.playoffAttributes,
         idPrefix: idPrefix && `${idPrefix}-po`,
         finishingPositionOffset,
         uuids: uuidsFMLC,
@@ -16164,12 +16211,212 @@ function drawPositionsAssignedParticipantIds({ structure, matchUp }) {
   return assignedParticipantIds?.length === 2;
 }
 
+const typeMatch = (arr, type) => arr.filter(Boolean).every((i) => typeof i === type);
+const allNumeric = (arr) => arr.filter(Boolean).every(isNumeric);
+function getCategoryAgeDetails(params) {
+  const category = params.category;
+  if (typeof category !== "object")
+    return { error: INVALID_CATEGORY };
+  let { ageCategoryCode, ageMaxDate, ageMinDate, ageMax, ageMin } = category;
+  const categoryName = category.categoryName;
+  let combinedAge;
+  if (!typeMatch(
+    [ageCategoryCode, ageMaxDate, ageMinDate, categoryName],
+    "string"
+  ) || !allNumeric(
+    [ageMax, ageMin]
+  ))
+    return { error: INVALID_CATEGORY };
+  const consideredDate = params.consideredDate ?? extractDate((/* @__PURE__ */ new Date()).toLocaleDateString("sv"));
+  if (!isValidDateString(consideredDate))
+    return { error: INVALID_DATE };
+  const [consideredYear] = consideredDate.split("-").slice(0, 3).map((n) => parseInt(n));
+  const previousDayDate = dateStringDaysChange(consideredDate, -1);
+  const [previousDayMonth, previousDay] = previousDayDate.split("-").slice(1, 3).map((n) => parseInt(n));
+  const previousMonthDay = `${zeroPad(previousDayMonth)}-${zeroPad(
+    previousDay
+  )}`;
+  const nextDayDate = dateStringDaysChange(consideredDate, 1);
+  const [nextDayMonth, nextDay] = nextDayDate.split("-").slice(1, 3).map((n) => parseInt(n));
+  const nextMonthDay = `${zeroPad(nextDayMonth)}-${zeroPad(nextDay)}`;
+  let calculatedAgeMaxDate = ageMin && dateStringDaysChange(consideredDate, -1 * 365 * ageMin);
+  let calculatedAgeMinDate = ageMax && dateStringDaysChange(consideredDate, -1 * 365 * ageMax);
+  const errors = [];
+  const addError = (errorString) => !errors.includes(errorString) && errors.push(errorString);
+  ageCategoryCode = ageCategoryCode ?? categoryName;
+  const prePost = /^([UO]?)(\d{1,2})([UO]?)$/;
+  const extractCombined = /^C(\d{1,2})-(\d{1,2})$/;
+  const isBetween = ageCategoryCode?.includes("-");
+  const isCombined = isBetween && ageCategoryCode?.match(extractCombined);
+  const isCoded = ageCategoryCode?.match(prePost);
+  const constructedDate = (y, df) => `${y}-${df}`;
+  const uPre = (ageInt) => {
+    const ageMinYear = consideredYear - ageInt;
+    const newMinDate = constructedDate(ageMinYear, nextMonthDay);
+    if (category.ageMinDate && category.ageMinDate !== newMinDate)
+      addError(`Invalid submitted ageMinDate: ${ageMinDate}`);
+    ageMinDate = newMinDate;
+    if (ageCategoryCode) {
+      if (category.ageMax && category.ageMax !== ageInt - 1) {
+        addError(`Invalid submitted ageMax: ${ageMax}`);
+        calculatedAgeMinDate = void 0;
+      }
+      ageMax = ageInt - 1;
+    }
+  };
+  const uPost = (ageInt) => {
+    const ageMinYear = consideredYear - ageInt - 1;
+    const newMinDate = constructedDate(ageMinYear, nextMonthDay);
+    if (category.ageMin && category.ageMin > ageInt) {
+      addError(`Invalid submitted ageMin: ${ageMin}`);
+    }
+    if (category.ageMax && category.ageMax > ageInt) {
+      addError(`Invalid submitted ageMax: ${ageMax}`);
+    }
+    if (category.ageMinDate && category.ageMinDate !== newMinDate)
+      addError(`Invalid submitted ageMinDate: ${ageMinDate}`);
+    ageMinDate = newMinDate;
+    if (ageCategoryCode) {
+      if (category.ageMax && category.ageMax !== ageInt) {
+        addError(`Invalid submitted ageMax: ${ageMax}`);
+        calculatedAgeMaxDate = void 0;
+      }
+      ageMax = ageInt;
+    }
+  };
+  const oPre = (ageInt) => {
+    const ageMaxYear = consideredYear - ageInt;
+    const newMaxDate = constructedDate(ageMaxYear, previousMonthDay);
+    if (category.ageMaxDate && category.ageMaxDate !== newMaxDate)
+      addError(`Invalid submitted ageMaxDate: ${ageMaxDate}`);
+    ageMaxDate = newMaxDate;
+    if (ageCategoryCode) {
+      if (category.ageMin && category.ageMin !== ageInt + 1) {
+        addError(`Invalid submitted ageMin: ${ageMin}`);
+        calculatedAgeMaxDate = void 0;
+      }
+      ageMin = ageInt + 1;
+    }
+  };
+  const oPost = (ageInt) => {
+    const ageMaxYear = consideredYear - ageInt - 1;
+    const newMaxDate = constructedDate(ageMaxYear, previousMonthDay);
+    if (category.ageMaxDate && category.ageMaxDate !== newMaxDate)
+      addError(`Invalid submitted ageMaxDate: ${ageMaxDate}`);
+    ageMaxDate = newMaxDate;
+    if (ageCategoryCode) {
+      if (category.ageMin && category.ageMin !== ageInt) {
+        addError(`Invalid submitted ageMin: ${ageMin}`);
+        calculatedAgeMaxDate = void 0;
+      }
+      ageMin = ageInt;
+    }
+  };
+  const processCode = (code) => {
+    const [pre, age, post] = (code.match(prePost) || []).slice(1);
+    const ageInt = parseInt(age);
+    if (pre === "U") {
+      if (category.ageMaxDate && category.ageMaxDate !== ageMaxDate) {
+        addError(`Invalid submitted ageMaxDate: ${category.ageMaxDate}`);
+      }
+      uPre(ageInt);
+    } else if (pre === "O") {
+      oPre(ageInt);
+    }
+    if (post === "U") {
+      if (category.ageMaxDate && category.ageMaxDate !== ageMaxDate) {
+        addError(`Invalid submitted ageMaxDate: ${category.ageMaxDate}`);
+      }
+      uPost(ageInt);
+    } else if (post === "O") {
+      oPost(ageInt);
+    }
+    ageMaxDate = ageMaxDate ?? calculatedAgeMaxDate;
+    ageMinDate = ageMinDate ?? calculatedAgeMinDate;
+  };
+  if (isCombined) {
+    ageMaxDate = void 0;
+    ageMinDate = void 0;
+    ageMax = void 0;
+    ageMin = void 0;
+    if (category.ageMin) {
+      const ageMaxYear = consideredYear - category.ageMin;
+      ageMaxDate = constructedDate(ageMaxYear, previousMonthDay);
+    }
+    if (category.ageMax) {
+      const ageMinYear = consideredYear - category.ageMax - 1;
+      ageMinDate = constructedDate(ageMinYear, nextMonthDay);
+    }
+    const [lowAge, highAge] = (ageCategoryCode?.match(extractCombined) ?? []).slice(1).map((n) => parseInt(n));
+    if (lowAge <= highAge) {
+      ageMin = lowAge;
+      ageMax = highAge;
+      combinedAge = true;
+    } else {
+      addError(`Invalid combined age range ${ageCategoryCode}`);
+    }
+  } else if (isBetween) {
+    ageCategoryCode?.split("-").forEach(processCode);
+  } else if (isCoded) {
+    processCode(ageCategoryCode);
+  } else {
+    if (ageMin)
+      oPre(ageMin);
+    if (ageMax)
+      uPost(ageMax);
+  }
+  if (ageMax && category.ageMin && category.ageMin > ageMax) {
+    addError(`Invalid submitted ageMin: ${category.ageMin}`);
+    ageMin = void 0;
+  }
+  const result = definedAttributes({
+    consideredDate,
+    combinedAge,
+    ageMaxDate,
+    ageMinDate,
+    ageMax,
+    ageMin
+  });
+  if (errors.length)
+    result.errors = errors;
+  return result;
+}
+
+function categoryCanContain({
+  childCategory,
+  withDetails,
+  category
+}) {
+  const categoryDetails = getCategoryAgeDetails({ category });
+  const childCategoryDetails = getCategoryAgeDetails({
+    category: childCategory
+  });
+  const invalidAgeMin = childCategoryDetails.ageMin && (categoryDetails.ageMin && childCategoryDetails.ageMin < categoryDetails.ageMin || categoryDetails.ageMax && childCategoryDetails.ageMin > categoryDetails.ageMax);
+  const invalidAgeMax = childCategoryDetails.ageMax && (categoryDetails.ageMax && childCategoryDetails.ageMax > categoryDetails.ageMax || categoryDetails.ageMin && childCategoryDetails.ageMax < categoryDetails.ageMin);
+  const invalidAgeMinDate = childCategoryDetails.ageMinDate && categoryDetails.ageMaxDate && new Date(childCategoryDetails.ageMinDate) > new Date(categoryDetails.ageMaxDate);
+  const invalidAgeMaxDate = childCategoryDetails.ageMaxDate && categoryDetails.ageMinDate && new Date(childCategoryDetails.ageMaxDate) < new Date(categoryDetails.ageMinDate);
+  const valid = !invalidAgeMax && !invalidAgeMin && !invalidAgeMinDate && !invalidAgeMaxDate;
+  const ignoreFalse = true;
+  const result = definedAttributes(
+    {
+      valid,
+      invalidAgeMax,
+      invalidAgeMin,
+      invalidAgeMinDate,
+      invalidAgeMaxDate
+    },
+    ignoreFalse
+  );
+  if (withDetails) {
+    Object.assign(result, { categoryDetails, childCategoryDetails });
+  }
+  return result;
+}
+
 function stringify(matchUpFormatObject, preserveRedundant) {
   if (typeof matchUpFormatObject !== "object")
     return;
-  if (matchUpFormatObject.timed && !isNaN(matchUpFormatObject.minutes))
-    return timedSetFormat(matchUpFormatObject);
-  if (matchUpFormatObject.bestOf && matchUpFormatObject.setFormat)
+  if ((matchUpFormatObject.bestOf || matchUpFormatObject.exactly) && matchUpFormatObject.setFormat)
     return getSetFormat(matchUpFormatObject, preserveRedundant);
   return void 0;
 }
@@ -16185,11 +16432,13 @@ function timedSetFormat(matchUpFormatObject) {
   return value;
 }
 function getSetFormat(matchUpFormatObject, preserveRedundant) {
-  const bestOfValue = getNumber(matchUpFormatObject.bestOf);
-  if (matchUpFormatObject.setFormat?.timed && matchUpFormatObject.simplified && bestOfValue === 1) {
+  const bestOfValue = getNumber(matchUpFormatObject.bestOf) || void 0;
+  const exactly = getNumber(matchUpFormatObject.exactly) || void 0;
+  const setLimit = bestOfValue || exactly;
+  if (matchUpFormatObject.setFormat?.timed && matchUpFormatObject.simplified && setLimit === 1) {
     return timedSetFormat(matchUpFormatObject.setFormat);
   }
-  const bestOfCode = bestOfValue && `${SET}${bestOfValue}` || "";
+  const setLimitCode = setLimit && `${SET}${setLimit}` || "";
   const setCountValue = stringifySet(
     matchUpFormatObject.setFormat,
     preserveRedundant
@@ -16199,11 +16448,11 @@ function getSetFormat(matchUpFormatObject, preserveRedundant) {
     matchUpFormatObject.finalSetFormat,
     preserveRedundant
   );
-  const finalSetCode = bestOfValue && bestOfValue > 1 && finalSetCountValue && setCountValue !== finalSetCountValue && // don't include final set code if equivalent to other sets
+  const finalSetCode = setLimit && setLimit > 1 && finalSetCountValue && setCountValue !== finalSetCountValue && // don't include final set code if equivalent to other sets
   `F:${finalSetCountValue}` || "";
-  const valid = bestOfCode && setCountValue;
+  const valid = setLimitCode && setCountValue;
   if (valid) {
-    return [bestOfCode, setCode, finalSetCode].filter((f) => f).join("-");
+    return [setLimitCode, setCode, finalSetCode].filter((f) => f).join("-");
   }
   return void 0;
 }
@@ -16272,6 +16521,7 @@ const matchUpFormatCode = {
 };
 
 function validateTieFormat(params) {
+  const checkCategory = !!(params?.enforceCategory !== false && params?.category);
   const checkGender = !!(params?.enforceGender !== false && params?.gender);
   const checkCollectionIds = params?.checkCollectionIds;
   const tieFormat = params?.tieFormat;
@@ -16308,9 +16558,11 @@ function validateTieFormat(params) {
       if ((setValue || scoreValue) && !collectionValue)
         aggregateValueImperative = true;
       const { valid: valid2, errors: collectionDefinitionErrors } = validateCollectionDefinition({
+        referenceCategory: params.category,
         referenceGender: params.gender,
         collectionDefinition,
         checkCollectionIds,
+        checkCategory,
         checkGender
       });
       if (valid2) {
@@ -16352,19 +16604,22 @@ function validateTieFormat(params) {
   return result;
 }
 function validateCollectionDefinition({
+  checkCategory = true,
   collectionDefinition,
   checkCollectionIds,
   checkGender = true,
+  referenceCategory,
   referenceGender,
   event
 }) {
   referenceGender = referenceGender ?? event?.gender;
+  const stack = "validateCollectionDefinition";
   const errors = [];
   if (typeof collectionDefinition !== "object") {
     errors.push(
       `collectionDefinition must be an object: ${collectionDefinition}`
     );
-    return { errors, error: INVALID_OBJECT };
+    return decorateResult({ result: { errors, error: INVALID_OBJECT }, stack });
   }
   const {
     collectionValueProfiles,
@@ -16377,6 +16632,7 @@ function validateCollectionDefinition({
     matchUpType,
     scoreValue,
     setValue,
+    category,
     gender
   } = collectionDefinition;
   if (checkCollectionIds && typeof collectionId !== "string") {
@@ -16422,8 +16678,23 @@ function validateCollectionDefinition({
   if (checkGender && referenceGender && gender && [GenderEnum.Male, GenderEnum.Female].includes(referenceGender) && referenceGender !== gender) {
     errors.push(`Invalid gender: ${gender}`);
   }
+  if (checkCategory && referenceCategory && category) {
+    const result = categoryCanContain({
+      category: referenceCategory,
+      childCategory: category
+    });
+    if (!result.valid)
+      return decorateResult({
+        result: { error: INVALID_CATEGORY },
+        context: result,
+        stack
+      });
+  }
   if (errors.length)
-    return { errors, error: INVALID_OBJECT };
+    return decorateResult({
+      result: { errors, error: INVALID_COLLECTION_DEFINITION },
+      stack
+    });
   return { valid: true };
 }
 function checkTieFormat(tieFormat) {
@@ -19111,7 +19382,7 @@ function generateRoundRobinWithPlayOff(params) {
   };
   const { structures, groupCount, groupSize } = generateRoundRobin(mainDrawProperties);
   if (groupCount < 1) {
-    console.log(INVALID_CONFIGURATION);
+    return { error: INVALID_CONFIGURATION };
   }
   const playoffGroups = structureOptions?.playoffGroups || [
     { finishingPositions: [1], structureName: constantToString(PLAY_OFF) }
@@ -22715,8 +22986,8 @@ function prepareStage(params) {
     });
     if (!scaledEntries?.length && seedByRanking) {
       const rankingScaleAttributes = {
-        scaleType: RANKING,
         scaleName: categoryName || ageCategoryCode,
+        scaleType: RANKING,
         eventType
       };
       ({ scaledEntries } = getScaledEntries({