tods-competition-factory 1.8.2 → 1.8.4

package/dist/index.mjs

@@ -333,7 +333,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.8.2";
+  return "1.8.4";
 }
 
 function getObjectTieFormat(obj) {
@@ -396,10 +396,6 @@ function resolveTieFormat({
   };
 }
 
-function mustBeAnArray(value) {
-  return `${value} must be an array`;
-}
-
 function unique(arr) {
   return arr.filter((item, i, s) => s.lastIndexOf(item) === i);
 }
@@ -1166,10 +1162,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"
@@ -1270,6 +1274,8 @@ const errorConditionConstants = {
   INVALID_ACTION,
   INVALID_ASSIGNMENT,
   INVALID_BOOKINGS,
+  INVALID_CATEGORY,
+  INVALID_COLLECTION_DEFINITION,
   INVALID_CONFIGURATION,
   INVALID_DATE_AVAILABILITY,
   INVALID_DATE,
@@ -1712,6 +1718,9 @@ function setTournamentId(tournamentId) {
 function removeTournamentRecord(tournamentId) {
   return _globalStateProvider.removeTournamentRecord(tournamentId);
 }
+function getProvider() {
+  return _globalStateProvider;
+}
 function handleCaughtError({
   engineName,
   methodName,
@@ -2040,6 +2049,13 @@ const dateTime = {
 };
 
 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) {
@@ -2214,6 +2230,177 @@ function generateHashCode(o) {
   return [str.length, keyCount, charSum].map((e) => e.toString(36)).join("");
 }
 
+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 attributeFilter(params) {
   if (params === null)
     return {};
@@ -2415,6 +2602,41 @@ function UUID() {
   lut[d3 & 255] + lut[d3 >> 8 & 255] + lut[d3 >> 16 & 255] + lut[d3 >> 24 & 255];
 }
 
+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 mustBeAnArray(value) {
+  return `${value} must be an array`;
+}
+
 function decorateResult({
   context,
   result,
@@ -2553,6 +2775,7 @@ var ParticipantTypeEnum = /* @__PURE__ */ ((ParticipantTypeEnum2) => {
 })(ParticipantTypeEnum || {});
 
 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;
@@ -2589,9 +2812,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) {
@@ -2633,19 +2858,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,
@@ -2658,6 +2886,7 @@ function validateCollectionDefinition({
     matchUpType,
     scoreValue,
     setValue,
+    category,
     gender
   } = collectionDefinition;
   if (checkCollectionIds && typeof collectionId !== "string") {
@@ -2703,8 +2932,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) {
@@ -6441,20 +6685,20 @@ const ROUND_ROBIN_WITH_PLAYOFF = "ROUND_ROBIN_WITH_PLAYOFF";
 const DECIDER = "DECIDER";
 const BACKDRAW = "BACKDRAW";
 const COMPASS_ATTRIBUTES = {
-  0: { name: "EAST", abbreviation: "E" },
-  "0-1": { name: "WEST", abbreviation: "W" },
-  "0-2": { name: "NORTH", abbreviation: "N" },
-  "0-3": { name: "NORTHEAST", abbreviation: "NE" },
-  "0-1-1": { name: "SOUTH", abbreviation: "S" },
-  "0-1-2": { name: "SOUTHWEST", abbreviation: "SW" },
-  "0-2-1": { name: "NORTHWEST", abbreviation: "NW" },
-  "0-1-1-1": { name: "SOUTHEAST", abbreviation: "SE" }
+  0: { name: "East", abbreviation: "E" },
+  "0-1": { name: "West", abbreviation: "W" },
+  "0-2": { name: "North", abbreviation: "N" },
+  "0-3": { name: "Northeast", abbreviation: "NE" },
+  "0-1-1": { name: "South", abbreviation: "S" },
+  "0-1-2": { name: "Southwest", abbreviation: "SW" },
+  "0-2-1": { name: "Northwest", abbreviation: "NW" },
+  "0-1-1-1": { name: "Southeast", abbreviation: "SE" }
 };
 const OLYMPIC_ATTRIBUTES = {
-  0: { name: "EAST", abbreviation: "E" },
-  "0-1": { name: "WEST", abbreviation: "W" },
-  "0-2": { name: "NORTH", abbreviation: "N" },
-  "0-1-1": { name: "SOUTH", abbreviation: "S" }
+  0: { name: "East", abbreviation: "E" },
+  "0-1": { name: "West", abbreviation: "W" },
+  "0-2": { name: "North", abbreviation: "N" },
+  "0-1-1": { name: "South", abbreviation: "S" }
 };
 const WIN_RATIO = "WIN_RATIO";
 const ROUND_OUTCOME = "ROUND_OUTCOME";
@@ -17427,103 +17671,6 @@ const garman = {
   courtGenerator
 };
 
-const typeMatch = (arr, type) => arr.filter(Boolean).every((i) => typeof i === type);
-const allNumeric = (arr) => arr.filter(Boolean).every(isNumeric);
-function parseAgeCategoryCode({ consideredDate, category } = { consideredDate: "" }) {
-  const invalid = { error: INVALID_VALUES, ageMin: 8, ageMax: 99 };
-  if (typeof category !== "object" || !isValidDateString(consideredDate))
-    return invalid;
-  const consideredYear = parseInt(consideredDate.split("-")[0]);
-  const errors = [];
-  let { ageCategoryCode, ageMaxDate, ageMinDate, ageMax, ageMin } = category;
-  const categoryName = category.categoryName;
-  let combinedAge;
-  if (!typeMatch(
-    [ageCategoryCode, ageMaxDate, ageMinDate, categoryName],
-    "string"
-  ) || !allNumeric([ageMax, ageMin]))
-    return invalid;
-  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 isYYMM = (datePart) => datePart.match(/^\d{2}-\d{2}$/);
-  const constructedDate = (y, d, df) => isValidDateString(d) && d || d && isYYMM(d) && `${y}-${d}` || `${y}-${df}`;
-  const uPre = (ageInt) => {
-    const ageMinYear = consideredYear - ageInt;
-    ageMinDate = constructedDate(ageMinYear, ageMinDate, "01-01");
-    if (ageMax && ageMax !== ageInt - 1)
-      errors.push(`Invalid ageMax: ${ageMax}`);
-    if (!ageMax)
-      ageMax = ageInt - 1;
-    return { ageMinDate, ageMax };
-  };
-  const uPost = (ageInt) => {
-    const ageMinYear = consideredYear - ageInt - 1;
-    ageMinDate = constructedDate(ageMinYear, ageMinDate, "01-01");
-    if (ageMax && ageMax !== ageInt)
-      errors.push(`Invalid ageMax: ${ageMax}`);
-    if (!ageMax)
-      ageMax = ageInt;
-    return { ageMinDate, ageMax };
-  };
-  const oPre = (ageInt) => {
-    const ageMaxYear = consideredYear - ageInt - 2;
-    ageMaxDate = constructedDate(ageMaxYear, ageMaxDate, "12-31");
-    if (ageMin && ageMin !== ageInt + 1)
-      errors.push(`Invalid ageMin: ${ageMin}`);
-    if (!ageMin)
-      ageMin = ageInt + 1;
-    return { ageMaxDate, ageMin };
-  };
-  const oPost = (ageInt) => {
-    const ageMaxYear = consideredYear - ageInt - 1;
-    ageMaxDate = constructedDate(ageMaxYear, ageMaxDate, "12-31");
-    if (ageMin && ageMin !== ageInt)
-      errors.push(`Invalid ageMin: ${ageMin}`);
-    if (!ageMin)
-      ageMin = ageInt;
-    return { ageMaxDate, ageMin };
-  };
-  const processCode = (code) => {
-    const [pre, age, post] = (code.match(prePost) || []).slice(1);
-    const ageInt = parseInt(age);
-    if (pre === "U")
-      ({ ageMinDate, ageMax } = uPre(ageInt));
-    if (post === "U")
-      ({ ageMinDate, ageMax } = uPost(ageInt));
-    if (pre === "O")
-      ({ ageMaxDate, ageMin } = oPre(ageInt));
-    if (post === "O")
-      ({ ageMaxDate, ageMin } = oPost(ageInt));
-  };
-  if (isCombined) {
-    const [lowAge, highAge] = (ageCategoryCode?.match(extractCombined) ?? []).slice(1).map((n) => parseInt(n));
-    if (lowAge <= highAge) {
-      ageMin = ageMin ?? lowAge;
-      ageMax = ageMax ?? highAge;
-      combinedAge = true;
-    } else {
-      errors.push(`Invalid combined age range ${ageCategoryCode}`);
-    }
-  } else if (isBetween) {
-    ageCategoryCode?.split("-").forEach(processCode);
-  } else if (isCoded) {
-    processCode(ageCategoryCode);
-  }
-  if (errors.length)
-    return { error: errors, ageMin: 8, ageMax: 99 };
-  return definedAttributes({
-    combinedAge,
-    ageMaxDate,
-    ageMinDate,
-    ageMax,
-    ageMin
-  });
-}
-
 function parseScoreString({
   tiebreakTo = 7,
   scoreString
@@ -23108,21 +23255,25 @@ const structureTemplate = ({
   return structure;
 };
 
-function generateRoundRobin({
-  structureName = constantToString(MAIN),
-  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,
@@ -23142,12 +23293,13 @@ function generateRoundRobin({
     maxRoundNumber = Math.max(
       ...matchUps.map(({ roundNumber }) => roundNumber)
     );
+    const structureName2 = groupNames?.[structureOrder - 1] ?? `${groupNameBase} ${structureOrder}`;
     return structureTemplate({
-      structureName: `Group ${structureOrder}`,
       structureId: uuids?.pop(),
       structureType: ITEM,
       finishingPosition,
       structureOrder,
+      structureName: structureName2,
       matchUps
     });
   });
@@ -30304,7 +30456,9 @@ function removeCollectionDefinition(params) {
 function addCollectionDefinition$1({
   updateInProgressMatchUps = true,
   collectionDefinition,
+  referenceCategory,
   tournamentRecord,
+  enforceCategory,
   referenceGender,
   drawDefinition,
   tieFormatName,
@@ -30322,16 +30476,21 @@ function addCollectionDefinition$1({
     drawDefinition,
     event
   }).appliedPolicies ?? {};
-  enforceGender = enforceGender ?? appliedPolicies?.[POLICY_TYPE_MATCHUP_ACTIONS]?.participants?.enforceGender;
-  const checkGender = !!(enforceGender !== false && event?.gender);
-  const { valid, errors } = validateCollectionDefinition({
+  const matchUpActionsPolicy = appliedPolicies?.[POLICY_TYPE_MATCHUP_ACTIONS];
+  enforceCategory = enforceCategory ?? matchUpActionsPolicy?.participants?.enforceCategory;
+  enforceGender = enforceGender ?? matchUpActionsPolicy?.participants?.enforceGender;
+  const checkCategory = !!((referenceCategory ?? event?.category) && enforceCategory !== false);
+  const checkGender = !!((referenceGender ?? event?.gender) && enforceGender !== false);
+  const validationResult = validateCollectionDefinition({
+    referenceCategory: referenceCategory ?? event?.category,
     collectionDefinition,
     referenceGender,
+    checkCategory,
     checkGender,
     event
   });
-  if (!valid) {
-    return decorateResult({ result: { error: INVALID_VALUES, errors }, stack });
+  if (validationResult.error) {
+    return decorateResult({ result: validationResult, stack });
   }
   let result = !matchUp?.tieFormat ? getTieFormat$1({
     drawDefinition,
@@ -36990,6 +37149,8 @@ const POLICY_MATCHUP_ACTIONS_DEFAULT = {
       }
     ],
     participants: {
+      enforceCategory: true,
+      // validate collectionDefinition.category against event.category
       enforceGender: true
       // disallow placing FEMALEs in MALE events and vice versa
     },
@@ -39230,7 +39391,7 @@ function competitionEngineAsync(test) {
 }
 
 function addVoluntaryConsolationStructure$1({
-  structureName = VOLUNTARY_CONSOLATION,
+  structureName = constantToString(VOLUNTARY_CONSOLATION),
   structureAbbreviation,
   drawDefinition,
   matchUpType,
@@ -39458,7 +39619,9 @@ function generateQualifyingStructures({
       }
       const roundTargetName = qualifyingProfiles.length > 1 ? `${roundTarget}-` : "";
       const stageSequenceName = structureProfiles.length > 1 || roundTargetName ? stageSequence : "";
-      const qualifyingStructureName = structureName || (roundTargetName || stageSequenceName ? `${QUALIFYING} ${roundTargetName}${stageSequenceName}` : QUALIFYING);
+      const qualifyingStructureName = structureName || (roundTargetName || stageSequenceName ? `${constantToString(
+        QUALIFYING
+      )} ${roundTargetName}${stageSequenceName}` : constantToString(QUALIFYING));
       if (drawType === ROUND_ROBIN) {
         const {
           structures: structures2,
@@ -40104,6 +40267,7 @@ function roundMatchCounts({ drawSize }) {
 function firstRoundLoserConsolation(params) {
   const {
     finishingPositionOffset = 0,
+    playoffAttributes,
     stageSequence = 1,
     staggeredEntry,
     structureName,
@@ -40125,7 +40289,7 @@ function firstRoundLoserConsolation(params) {
   };
   const { matchUps } = staggeredEntry ? feedInMatchUps(mainParams) : treeMatchUps(mainParams);
   const mainStructure = structureTemplate({
-    structureName: structureName || constantToString(MAIN),
+    structureName: structureName || playoffAttributes?.["0"]?.name || constantToString(MAIN),
     structureId: structureId || uuids?.pop(),
     stageSequence,
     matchUpType,
@@ -40144,7 +40308,7 @@ function firstRoundLoserConsolation(params) {
       isMock
     });
     const consolation = constantToString(CONSOLATION);
-    const consolationStructureName = params.consolationStructureName || (structureName ? `${structureName} ${consolation}` : consolation);
+    const consolationStructureName = playoffAttributes?.["0-1"]?.name ?? params.consolationStructureName ?? (structureName ? `${structureName} ${consolation}` : consolation);
     const consolationStructure = structureTemplate({
       structureName: consolationStructureName,
       matchUps: consolationMatchUps,
@@ -40222,10 +40386,10 @@ function feedInLinks({
 
 function generateCurtisConsolation(params) {
   const {
-    structureName = constantToString(MAIN),
     playoffStructureNameBase,
     finishingPositionOffset,
     stageSequence = 1,
+    playoffAttributes,
     structureNameMap,
     staggeredEntry,
     stage = MAIN,
@@ -40245,6 +40409,7 @@ function generateCurtisConsolation(params) {
     uuids
   };
   const { matchUps, roundsCount: mainDrawRoundsCount } = staggeredEntry ? feedInMatchUps(mainParams) : treeMatchUps(mainParams);
+  const structureName = params.structureName ?? playoffAttributes?.["0"]?.name ?? constantToString(MAIN);
   const mainStructure = structureTemplate({
     structureId: structureId || uuids?.pop(),
     structureName,
@@ -40263,6 +40428,7 @@ function generateCurtisConsolation(params) {
         idPrefix: idPrefix && `${idPrefix}-c${index}`,
         structureId: uuids?.pop(),
         playoffStructureNameBase,
+        playoffAttributes,
         structureNameMap,
         stageSequence: stageSequence2,
         roundOffset,
@@ -40291,7 +40457,7 @@ function generateCurtisConsolation(params) {
         matchUpType,
         isMock
       });
-      const defaultName = constantToString(PLAY_OFF);
+      const defaultName = playoffAttributes?.["3-4"]?.name ?? constantToString(PLAY_OFF);
       const mappedStructureName = structureNameMap?.[defaultName] || defaultName;
       const structureName2 = playoffStructureNameBase ? `${playoffStructureNameBase} ${mappedStructureName}` : mappedStructureName;
       const playoffStructure = structureTemplate({
@@ -40323,6 +40489,7 @@ function generateCurtisConsolation(params) {
 function consolationFeedStructure({
   playoffStructureNameBase,
   stageSequence = 1,
+  playoffAttributes,
   structureNameMap,
   roundOffset = 0,
   matchUpType,
@@ -40344,7 +40511,8 @@ function consolationFeedStructure({
     isMock,
     uuids
   });
-  const defaultName = `${constantToString(CONSOLATION)} ${index + 1}`;
+  const indexedStructureName = index === 0 && playoffAttributes?.["0-1"]?.name || index === 1 && playoffAttributes?.["0-3"]?.name;
+  const defaultName = indexedStructureName || `${constantToString(CONSOLATION)} ${index + 1}`;
   const mappedStructureName = structureNameMap?.[defaultName] || defaultName;
   const structureName = playoffStructureNameBase ? `${playoffStructureNameBase} ${mappedStructureName}` : mappedStructureName;
   const consolationStructure = structureTemplate({
@@ -40394,8 +40562,8 @@ function generatePlayoffStructures(params) {
   const finishingPositionRange = `${finishingPositionsFrom}-${finishingPositionsTo}`;
   const attributeProfile = playoffAttributes?.[exitProfile];
   const base = playoffStructureNameBase && `${playoffStructureNameBase} ` || "";
-  const customNaming = finishingPositionNaming?.[finishingPositionRange];
-  const structureName = customNaming?.name || attributeProfile?.name && (addNameBaseToAttributeName ? `${base}${attributeProfile?.name}` : attributeProfile.name) || `${base}${finishingPositionRange}`;
+  const customNaming = playoffAttributes?.[finishingPositionRange] ?? finishingPositionNaming?.[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`,
@@ -40499,6 +40667,7 @@ function feedInChampionship(params) {
   const {
     finishingPositionOffset,
     stageSequence = 1,
+    playoffAttributes,
     policyDefinitions,
     feedsFromFinal,
     staggeredEntry,
@@ -40526,7 +40695,7 @@ function feedInChampionship(params) {
   };
   const { matchUps } = staggeredEntry ? feedInMatchUps(mainParams) : treeMatchUps(mainParams);
   const mainStructure = structureTemplate({
-    structureName: structureName || constantToString(MAIN),
+    structureName: structureName || playoffAttributes?.["0"]?.name || constantToString(MAIN),
     structureId: structureId || uuids?.pop(),
     stageSequence,
     matchUpType,
@@ -40550,12 +40719,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: constantToString(CONSOLATION),
       matchUps: consolationMatchUps,
       structureId: uuids?.pop(),
       stage: CONSOLATION,
       stageSequence: 1,
+      structureName: structureName2,
       matchUpType
     });
     structures.push(consolationStructure);
@@ -40576,10 +40747,9 @@ function feedInChampionship(params) {
 }
 
 function processPlayoffGroups({
-  compassAttributes = COMPASS_ATTRIBUTES,
-  olympicAttributes = OLYMPIC_ATTRIBUTES,
   requireSequential = true,
   playoffMatchUpFormat,
+  playoffAttributes,
   sourceStructureId,
   policyDefinitions,
   stageSequence,
@@ -40628,6 +40798,8 @@ function processPlayoffGroups({
     if (positionsPlayedOff) {
       finishingPositionOffset = Math.min(...positionsPlayedOff) - 1;
     }
+    const finishingPositionRange = positionsPlayedOff && `${Math.min(...positionsPlayedOff)}-${Math.max(...positionsPlayedOff)}`;
+    const structureName = playoffGroup.structureName || finishingPositionRange && playoffGroup.playoffAttributes?.[finishingPositionRange]?.name || playoffGroup.playoffAttributes?.["0"]?.name;
     const playoffGroupParams = {
       addNameBaseToAttributeName: playoffGroup.addNameBaseToAttributeName,
       playoffStructureNameBase: playoffGroup.playoffStructureNameBase,
@@ -40636,8 +40808,8 @@ function processPlayoffGroups({
       structureId: playoffGroup.structureId ?? uuids?.pop(),
       playoffAttributes: playoffGroup.playoffAttributes,
       structureNameMap: playoffGroup.structureNameMap,
-      structureName: playoffGroup.structureName,
-      sequenceLimit: playoffGroup.sequenceLimit
+      sequenceLimit: playoffGroup.sequenceLimit,
+      structureName
     };
     const params = {
       ...playoffGroupParams,
@@ -40679,9 +40851,9 @@ function processPlayoffGroups({
       });
       const playoffStructure = structureTemplate({
         structureId: playoffGroup.structureId ?? uuids?.pop(),
-        structureName: playoffGroup.structureName,
         matchUpFormat: playoffMatchUpFormat,
         stage: PLAY_OFF,
+        structureName,
         stageSequence,
         matchUps
       });
@@ -40698,10 +40870,11 @@ function processPlayoffGroups({
         finishingPositions
       });
     } else if ([COMPASS, OLYMPIC, PLAY_OFF].includes(playoffDrawType)) {
-      const { structureName } = playoffGroup;
       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,
@@ -40714,12 +40887,12 @@ function processPlayoffGroups({
       };
       if (playoffDrawType === COMPASS) {
         Object.assign(params2, {
-          playoffAttributes: compassAttributes,
+          playoffAttributes: playoffGroup?.playoffAttributes ?? playoffAttributes ?? COMPASS_ATTRIBUTES,
           roundOffsetLimit: 3
         });
       } else if (playoffDrawType === OLYMPIC) {
         Object.assign(params2, {
-          playoffAttributes: olympicAttributes,
+          playoffAttributes: playoffGroup?.playoffAttributes ?? playoffAttributes ?? OLYMPIC_ATTRIBUTES,
           roundOffsetLimit: 2
         });
       }
@@ -40754,12 +40927,14 @@ function processPlayoffGroups({
     ].includes(playoffDrawType)) {
       const uuidsFMLC = [uuids?.pop(), uuids?.pop()];
       const params2 = {
+        playoffStructureNameBase: playoffGroup.playoffStructureNameBase,
         structureId: playoffGroup.structureId ?? uuids?.pop(),
-        structureName: playoffGroup.structureName,
+        playoffAttributes: playoffGroup.playoffAttributes,
         idPrefix: idPrefix && `${idPrefix}-po`,
         finishingPositionOffset,
         uuids: uuidsFMLC,
         stage: PLAY_OFF,
+        structureName,
         matchUpType,
         feedPolicy,
         drawSize,
@@ -40845,7 +41020,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) }
@@ -41111,10 +41286,8 @@ function luckyRoundProfiles(drawSize) {
 
 function getGenerators(params) {
   const {
-    compassAttributes = COMPASS_ATTRIBUTES,
-    olympicAttributes = OLYMPIC_ATTRIBUTES,
+    playoffAttributes,
     stageSequence = 1,
-    structureName,
     structureId,
     stage = MAIN,
     matchUpType,
@@ -41124,13 +41297,13 @@ 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 structureName = params.structureName ?? playoffAttributes?.["0"]?.name ?? constantToString(MAIN);
   const singleElimination = () => {
     const { matchUps } = treeMatchUps(params);
     const structure = structureTemplate({
       structureId: structureId || uuids?.pop(),
-      structureName: structureName || main,
       stageSequence,
+      structureName,
       matchUpType,
       matchUps,
       stage
@@ -41141,9 +41314,9 @@ function getGenerators(params) {
     [AD_HOC]: () => {
       const structure = structureTemplate({
         structureId: structureId || uuids?.pop(),
-        structureName: structureName || main,
         finishingPosition: WIN_RATIO,
         stageSequence,
+        structureName,
         matchUps: [],
         matchUpType,
         stage
@@ -41154,8 +41327,8 @@ function getGenerators(params) {
       const { matchUps } = luckyDraw(params);
       const structure = structureTemplate({
         structureId: structureId || uuids?.pop(),
-        structureName: structureName || main,
         stageSequence,
+        structureName,
         matchUpType,
         matchUps,
         stage
@@ -41167,12 +41340,12 @@ function getGenerators(params) {
     [COMPASS]: () => generatePlayoffStructures({
       ...params,
       roundOffsetLimit: 3,
-      playoffAttributes: compassAttributes
+      playoffAttributes: playoffAttributes ?? COMPASS_ATTRIBUTES
     }),
     [OLYMPIC]: () => generatePlayoffStructures({
       ...params,
       roundOffsetLimit: 2,
-      playoffAttributes: olympicAttributes
+      playoffAttributes: playoffAttributes ?? OLYMPIC_ATTRIBUTES
     }),
     [PLAY_OFF]: () => {
       return generatePlayoffStructures(params);
@@ -41181,8 +41354,8 @@ function getGenerators(params) {
       const { matchUps } = feedInMatchUps({ drawSize, uuids, matchUpType });
       const structure = structureTemplate({
         structureId: structureId || uuids?.pop(),
-        structureName: structureName || main,
         stageSequence,
+        structureName,
         matchUpType,
         stage: MAIN,
         matchUps
@@ -44221,7 +44394,7 @@ function generateQualifyingStructure$1(params) {
   }
   const roundTargetName = roundTarget ? `${roundTarget}-` : "";
   const stageSequenceName = `${stageSequence}`;
-  const qualifyingStructureName = structureName || (roundTargetName || stageSequenceName ? `${QUALIFYING} ${roundTargetName}${stageSequenceName}` : QUALIFYING);
+  const qualifyingStructureName = structureName || (roundTargetName || stageSequenceName ? `${constantToString(QUALIFYING)} ${roundTargetName}${stageSequenceName}` : constantToString(QUALIFYING));
   if (drawType === ROUND_ROBIN) {
     const { maxRoundNumber, structures, groupCount } = generateRoundRobin({
       structureName: structureName || qualifyingStructureName,
@@ -58232,8 +58405,8 @@ function prepareStage(params) {
     });
     if (!scaledEntries?.length && seedByRanking) {
       const rankingScaleAttributes = {
-        scaleType: RANKING$1,
         scaleName: categoryName || ageCategoryCode,
+        scaleType: RANKING$1,
         eventType
       };
       ({ scaledEntries } = getScaledEntries({
@@ -61256,7 +61429,7 @@ function generatePersons(params) {
       shuffledPersons.push(person);
     });
   }
-  const { ageMinDate, ageMaxDate } = parseAgeCategoryCode({
+  const { ageMinDate, ageMaxDate } = getCategoryAgeDetails({
     consideredDate,
     category
   });
@@ -64117,7 +64290,8 @@ const utilities = {
   nextPowerOf2,
   numericSort,
   overlap,
-  parseAgeCategoryCode,
+  getCategoryAgeDetails,
+  categoryCanContain,
   randomMember,
   randomPop,
   shuffleArray,