tods-competition-factory 1.7.6 → 1.7.8

package/dist/index.mjs

@@ -333,7 +333,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.7.6";
+  return "1.7.8";
 }
 
 function getObjectTieFormat(obj) {
@@ -1727,116 +1727,6 @@ function handleCaughtError({
   });
 }
 
-function isObject(obj) {
-  return typeof obj === "object";
-}
-const hasAttributeValues = (a) => (o) => Object.keys(a).every((key) => o[key] === a[key]);
-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 countKeys(o) {
-  if (Array.isArray(o)) {
-    return o.length + o.map(countKeys).reduce((a, b) => a + b, 0);
-  } else if (typeof o === "object" && o !== null) {
-    return Object.keys(o).length + Object.keys(o).map((k) => countKeys(o[k])).reduce((a, b) => a + b, 0);
-  }
-  return 0;
-}
-function generateHashCode(o) {
-  if (o === null || typeof o !== "object")
-    return void 0;
-  const str = JSON.stringify(o);
-  const keyCount = countKeys(o);
-  const charSum = str.split("").reduce((a, b) => a + b.charCodeAt(0), 0);
-  return [str.length, keyCount, charSum].map((e) => e.toString(36)).join("");
-}
-
-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 generateTimeCode(index = 0) {
-  const uidate = /* @__PURE__ */ new Date();
-  uidate.setHours(uidate.getHours() + index);
-  return uidate.getTime().toString(36).slice(-6).toUpperCase();
-}
-
 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?$/;
@@ -2206,6 +2096,182 @@ 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";
+}
+function createMap(objectArray, attribute) {
+  if (!Array.isArray(objectArray))
+    return {};
+  return Object.assign(
+    {},
+    ...(objectArray ?? []).filter(isObject).map((obj) => {
+      return obj[attribute] && {
+        [obj[attribute]]: obj
+      };
+    }).filter(Boolean)
+  );
+}
+const hasAttributeValues = (a) => (o) => Object.keys(a).every((key) => o[key] === a[key]);
+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 countKeys(o) {
+  if (Array.isArray(o)) {
+    return o.length + o.map(countKeys).reduce((a, b) => a + b, 0);
+  } else if (typeof o === "object" && o !== null) {
+    return Object.keys(o).length + Object.keys(o).map((k) => countKeys(o[k])).reduce((a, b) => a + b, 0);
+  }
+  return 0;
+}
+function generateHashCode(o) {
+  if (o === null || typeof o !== "object")
+    return void 0;
+  const str = JSON.stringify(o);
+  const keyCount = countKeys(o);
+  const charSum = str.split("").reduce((a, b) => a + b.charCodeAt(0), 0);
+  return [str.length, keyCount, charSum].map((e) => e.toString(36)).join("");
+}
+
+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 generateTimeCode(index = 0) {
+  const uidate = /* @__PURE__ */ new Date();
+  uidate.setHours(uidate.getHours() + index);
+  return uidate.getTime().toString(36).slice(-6).toUpperCase();
+}
+
 function numericSort(a, b) {
   return a - b;
 }
@@ -4217,7 +4283,8 @@ function getCollectionPositionMatchUps({ matchUps }) {
 
 const add = (a, b) => (a || 0) + (b || 0);
 function getBand(spread, bandProfiles) {
-  return isNaN(spread) && WALKOVER$1 || spread <= bandProfiles[DECISIVE] && DECISIVE || spread <= bandProfiles[ROUTINE] && ROUTINE || COMPETITIVE;
+  const spreadValue = Array.isArray(spread) ? spread[0] : spread;
+  return isNaN(spreadValue) && WALKOVER$1 || spreadValue <= bandProfiles[DECISIVE] && DECISIVE || spreadValue <= bandProfiles[ROUTINE] && ROUTINE || COMPETITIVE;
 }
 function getScoreComponents({ score }) {
   const sets = score?.sets || [];
@@ -4287,7 +4354,8 @@ function getMatchUpCompetitiveProfile({
   const scoreComponents = getScoreComponents({ score });
   const spread = pctSpread([scoreComponents]);
   const competitiveness = getBand(spread, bandProfiles);
-  return { ...SUCCESS, competitiveness, pctSpread: spread };
+  const pctSpreadValue = Array.isArray(spread) ? spread[0] : spread;
+  return { ...SUCCESS, competitiveness, pctSpread: pctSpreadValue };
 }
 
 function findMatchupFormatAverageTimes(params) {
@@ -7600,12 +7668,15 @@ 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 = {
   [POLICY_TYPE_ROUND_NAMING]: {
     policyName: "Round Naming Default",
+    namingConventions: {
+      round: "Round"
+    },
     abbreviatedRoundNamingMap: {
       // key is matchUpsCount for the round
       1: "F",
@@ -7645,6 +7716,9 @@ function getRoundContextProfile({
   const roundNamingMap = roundNamingPolicy?.roundNamingMap || defaultRoundNamingPolicy.roundNamingMap || {};
   const abbreviatedRoundNamingMap = roundNamingPolicy?.abbreviatedRoundNamingMap || defaultRoundNamingPolicy.abbreviatedRoundNamingMap || {};
   const roundNamePrefix = roundNamingPolicy?.affixes || defaultRoundNamingPolicy.affixes;
+  const roundNumberAffix = roundNamePrefix.roundNumber || defaultRoundNamingPolicy.affixes.roundNumber;
+  const namingConventions = roundNamingPolicy?.namingConventions || defaultRoundNamingPolicy.namingConventions;
+  const roundNameFallback = namingConventions.round;
   const stageInitial = stage && stage !== MAIN && stage[0];
   const stageConstants = roundNamingPolicy?.stageConstants;
   const stageConstant = stage && stageConstants?.[stage] || stageInitial;
@@ -7653,8 +7727,8 @@ function getRoundContextProfile({
     Object.assign(
       roundNamingProfile,
       ...roundProfileKeys.map((key) => {
-        const roundName = `Round ${key}`;
-        const abbreviatedRoundName = `R${key}`;
+        const roundName = `${roundNameFallback} ${key}`;
+        const abbreviatedRoundName = `${roundNumberAffix}${key}`;
         return { [key]: { roundName, abbreviatedRoundName } };
       })
     );
@@ -26130,56 +26204,6 @@ function getEventPublishStatuses({ event }) {
   return void 0;
 }
 
-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,
@@ -26381,8 +26405,8 @@ function modifyMatchUpFormatTiming$1({
       recoveryTimes
     });
     addTournamentExtension({
-      tournamentRecord,
-      extension: { name, value }
+      extension: { name, value },
+      tournamentRecord
     });
   }
   return { ...SUCCESS };
@@ -47470,7 +47494,10 @@ const matchUpGovernor = {
   validateScore
 };
 
-function attachPolicies({ drawDefinition, policyDefinitions }) {
+function attachPolicies({
+  drawDefinition,
+  policyDefinitions
+}) {
   if (!drawDefinition) {
     return { error: MISSING_DRAW_DEFINITION };
   }
@@ -47480,8 +47507,9 @@ function attachPolicies({ drawDefinition, policyDefinitions }) {
   if (!drawDefinition.extensions)
     drawDefinition.extensions = [];
   const appliedPolicies = getAppliedPolicies({ drawDefinition })?.appliedPolicies ?? {};
+  const validReplacements = [POLICY_TYPE_ROUND_NAMING, POLICY_TYPE_DISPLAY];
   const applied = Object.keys(policyDefinitions).every((policyType) => {
-    if (!appliedPolicies[policyType]) {
+    if (!appliedPolicies[policyType] || validReplacements.includes(policyType)) {
       appliedPolicies[policyType] = policyDefinitions[policyType];
       return true;
     } else {
@@ -50589,6 +50617,93 @@ function modifyParticipantOtherName({
   return { ...SUCCESS };
 }
 
+function formatPersonName({
+  personFormat,
+  person
+}) {
+  const alpha = (str) => str.replace(/\W/g, "");
+  const allLowerCase = (str) => /^[a-z]*$/.test(alpha(str));
+  const allUpperCase = (str) => /^[A-Z]*$/.test(alpha(str));
+  const lastUpperCase = (str) => /^[LAST]{4}/.test(alpha(str));
+  const lastFirst = (str) => str.toLowerCase().indexOf("l") < str.toLowerCase().indexOf("f");
+  const commaSeparated = (str) => str.indexOf(",") >= 0;
+  const firstInital = (str) => str.toLowerCase().indexOf("f.") >= 0;
+  const lastNameOnly = (str) => str.toLowerCase().indexOf("f") < 0;
+  const hasSpacing = (str) => str.indexOf(" ") > 0;
+  if (!person)
+    return;
+  const spacer = hasSpacing(personFormat) ? " " : "";
+  const capitalizeFirst = (str) => str.split(" ").map(
+    (name) => name.split("").map((c, i) => i ? c.toLowerCase() : c.toUpperCase()).join("")
+  ).join(" ");
+  let firstName = capitalizeFirst(person?.standardGivenName ?? "");
+  let lastName = capitalizeFirst(person?.standardFamilyName ?? "");
+  if (!personFormat)
+    return `${firstName}${spacer}${lastName}`;
+  if (firstInital(personFormat) && !commaSeparated(personFormat) && !lastFirst(personFormat)) {
+    firstName = `${firstName[0]}.`;
+  }
+  if (allLowerCase(personFormat)) {
+    firstName = firstName.toLowerCase();
+    lastName = lastName.toLowerCase();
+  } else if (allUpperCase(personFormat)) {
+    firstName = firstName.toUpperCase();
+    lastName = lastName.toUpperCase();
+  } else if (lastUpperCase(personFormat)) {
+    lastName = lastName.toUpperCase();
+  }
+  let participantName = `${firstName}${spacer}${lastName}`;
+  if (lastNameOnly(personFormat)) {
+    participantName = lastName;
+  } else if (lastFirst(personFormat)) {
+    if (commaSeparated(personFormat)) {
+      participantName = `${lastName},${spacer}${firstName}`;
+    } else {
+      participantName = `${lastName}${spacer}${firstName}`;
+    }
+  }
+  return participantName;
+}
+
+function formatParticipantName({
+  participantMap,
+  participant,
+  formats
+}) {
+  const { participantType, individualParticipantIds, person } = participant;
+  const format = participantType && formats[participantType];
+  if (participantType === TEAM_PARTICIPANT)
+    return;
+  if (format) {
+    const { personFormat, doublesJoiner } = format;
+    if (participantType === INDIVIDUAL) {
+      participant.participantName = formatPersonName({ person, personFormat });
+    }
+    if (participantType === PAIR) {
+      participant.participantName = individualParticipantIds?.map((id) => {
+        const person2 = participantMap[id]?.person;
+        return formatPersonName({ person: person2, personFormat });
+      }).filter(Boolean).join(doublesJoiner ?? "/");
+    }
+  }
+}
+
+function regenerateParticipantNames({
+  tournamentRecord,
+  formats
+}) {
+  if (!tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  if (!isObject(formats))
+    return { error: MISSING_VALUE };
+  const participants = tournamentRecord.participants ?? [];
+  const participantMap = createMap(participants, "participantId");
+  for (const participant of participants) {
+    formatParticipantName({ participant, participantMap, formats });
+  }
+  return { ...SUCCESS };
+}
+
 function getTournamentPersons({ tournamentRecord, participantFilters }) {
   if (!tournamentRecord)
     return { error: MISSING_TOURNAMENT_RECORD };
@@ -51082,6 +51197,7 @@ const participantGovernor = {
   removeParticipantIdsFromAllTeams,
   getParticipantMembership,
   generateTeamsFromParticipantAttribute,
+  regenerateParticipantNames,
   getParticipantIdFinishingPositions,
   modifyParticipant,
   modifyParticipantName,
@@ -56423,13 +56539,6 @@ function deleteFlightAndFlightDraw({
   return refreshEventDrawOrder({ tournamentRecord, event });
 }
 
-function generateAdHocMatchUps(params) {
-  return generateAdHocMatchUps$1(params);
-}
-function addAdHocMatchUps(params) {
-  return addAdHocMatchUps$1(params);
-}
-
 function attachFlightProfile({ deleteExisting, event, flightProfile }) {
   const stack = "attachFlightProfile";
   if (!flightProfile)
@@ -56635,6 +56744,98 @@ function deleteAdHocMatchUps(params) {
   return deleteAdHocMatchUps$1(params);
 }
 
+function modifyDrawName({
+  tournamentRecord,
+  drawDefinition,
+  flightProfile,
+  drawName,
+  drawId,
+  event
+}) {
+  if (!drawName || typeof drawName !== "string")
+    return decorateResult({
+      result: { error: INVALID_VALUES },
+      context: { drawName }
+    });
+  if (!flightProfile) {
+    flightProfile = getFlightProfile({ event }).flightProfile;
+  }
+  const flight = flightProfile?.flights?.find(
+    (flight2) => flight2.drawId === drawId
+  );
+  if (flight) {
+    flight.drawName = drawName;
+    const extension = {
+      name: FLIGHT_PROFILE,
+      value: {
+        ...flightProfile,
+        flights: flightProfile.flights
+      }
+    };
+    addEventExtension$1({ event, extension });
+  }
+  if (drawDefinition) {
+    drawDefinition.drawName = drawName;
+    modifyDrawNotice({
+      tournamentId: tournamentRecord?.tournamentId,
+      drawDefinition
+    });
+  }
+  if (!flight && !drawDefinition) {
+    return { error: MISSING_DRAW_DEFINITION };
+  }
+  return { ...SUCCESS, flight };
+}
+
+function modifyDrawDefinition({
+  tournamentRecord,
+  drawDefinition,
+  drawUpdates,
+  drawId,
+  event
+}) {
+  if (!isObject(drawUpdates))
+    return { error: INVALID_END_TIME };
+  const flightProfile = getFlightProfile({ event }).flightProfile;
+  const nameResult = drawUpdates.drawName && modifyDrawName({
+    drawName: drawUpdates.drawName,
+    tournamentRecord,
+    drawDefinition,
+    flightProfile,
+    drawId,
+    event
+  });
+  if (nameResult?.error)
+    return nameResult?.error;
+  const flight = nameResult?.flight || flightProfile?.flights?.find((flight2) => flight2.drawId === drawId);
+  if (!flight && !drawDefinition) {
+    return { error: MISSING_DRAW_DEFINITION };
+  }
+  if (flight) {
+    const extension = {
+      name: FLIGHT_PROFILE,
+      value: {
+        ...flightProfile,
+        flights: flightProfile.flights
+      }
+    };
+    addEventExtension$1({ event, extension });
+  }
+  if (drawDefinition) {
+    if (drawUpdates.policyDefinitions) {
+      attachPolicies({
+        policyDefinitions: drawUpdates.policyDefinitions,
+        drawDefinition
+      });
+    }
+    modifyDrawNotice({
+      tournamentId: tournamentRecord?.tournamentId,
+      drawDefinition
+    });
+  }
+  return { ...SUCCESS };
+}
+
 function resetDrawDefinition({
   tournamentRecord,
   removeScheduling,
@@ -56795,34 +56996,6 @@ function setOrderOfFinish(params) {
   return setOrderOfFinish$1(params);
 }
 
-function modifyDrawName({ event, drawId, drawDefinition, drawName }) {
-  if (!drawName || typeof drawName !== "string")
-    return { error: INVALID_VALUES, drawName };
-  const { flightProfile } = getFlightProfile({ event });
-  const flight = flightProfile?.flights?.find(
-    (flight2) => flight2.drawId === drawId
-  );
-  if (flight) {
-    flight.drawName = drawName;
-    const extension = {
-      name: FLIGHT_PROFILE,
-      value: {
-        ...flightProfile,
-        flights: flightProfile.flights
-      }
-    };
-    addEventExtension$1({ event, extension });
-  }
-  if (drawDefinition) {
-    drawDefinition.drawName = drawName;
-    modifyDrawNotice({ drawDefinition });
-  }
-  if (!flight && !drawDefinition) {
-    return { error: MISSING_DRAW_DEFINITION };
-  }
-  return { ...SUCCESS };
-}
-
 function modifyEventEntries({
   entryStatus = DIRECT_ACCEPTANCE,
   unpairedParticipantIds = [],
@@ -56958,6 +57131,13 @@ function addFlight({
   return addEventExtension$1({ event, extension });
 }
 
+function generateAdHocMatchUps(params) {
+  return generateAdHocMatchUps$1(params);
+}
+function addAdHocMatchUps(params) {
+  return addAdHocMatchUps$1(params);
+}
+
 function attachConsolationStructures(params) {
   return attachStructures({
     ...params,
@@ -58119,6 +58299,61 @@ function enableTieAutoCalc(params) {
   return enableTieAutoCalc$1(params);
 }
 
+function modifyEvent({
+  tournamentRecord,
+  eventUpdates,
+  eventId,
+  event
+}) {
+  if (!tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  if (!isString(eventId) || !isObject(eventUpdates))
+    return { error: INVALID_VALUES };
+  const enteredParticipantIds = event?.entries?.filter(({ entryStatus }) => {
+    const status = entryStatus;
+    return [...STRUCTURE_SELECTED_STATUSES, ALTERNATE].includes(status);
+  }).map(({ participantId }) => participantId) || [];
+  const enteredParticipants = enteredParticipantIds ? getParticipants$1({
+    participantFilters: { participantIds: enteredParticipantIds },
+    withIndividualParticipants: true,
+    tournamentRecord
+  }).participants || [] : [];
+  const genderAccumulator = [];
+  const enteredParticipantTypes = enteredParticipants.reduce(
+    (types, participant) => {
+      const genders = participant.person?.sex ? [participant.person.sex] : participant.individualParticpants?.map((p) => p.person?.sex) || [];
+      genderAccumulator.push(...genders);
+      return !types.includes(participant.participantType) ? types.concat(participant.participantType) : types;
+    },
+    []
+  );
+  const enteredParticipantGenders = unique(genderAccumulator);
+  const validGender = !enteredParticipantGenders.length || [MIXED, ANY].includes(eventUpdates.gender || "") || enteredParticipantGenders.length === 1 && enteredParticipantGenders[0] === eventUpdates.gender;
+  if (eventUpdates.gender && !validGender)
+    return decorateResult({
+      context: { gender: eventUpdates.gender },
+      result: { error: INVALID_VALUES }
+    });
+  const validEventTypes = enteredParticipantTypes.includes(TEAM$1) && [TEAM$1] || enteredParticipantTypes.includes(INDIVIDUAL) && [SINGLES] || enteredParticipantTypes.includes(PAIR) && [DOUBLES] || [
+    DOUBLES,
+    SINGLES,
+    TEAM$1
+  ];
+  const validEventType = validEventTypes.includes(eventUpdates.eventType || "");
+  if (eventUpdates.eventType && !validEventType)
+    return decorateResult({
+      context: { participantType: eventUpdates.eventType },
+      result: { error: INVALID_VALUES }
+    });
+  if (eventUpdates.eventType)
+    event.eventType === eventUpdates.eventType;
+  if (eventUpdates.eventName)
+    event.eventName = eventUpdates.eventName;
+  if (eventUpdates.gender)
+    event.gender = eventUpdates.gender;
+  return { ...SUCCESS };
+}
+
 const eventGovernor = {
   generateQualifyingStructure,
   attachQualifyingStructure,
@@ -58139,11 +58374,12 @@ const eventGovernor = {
   modifyTieFormat: modifyTieFormat$1,
   resetScorecard,
   resetTieFormat: resetTieFormat$1,
-  addEvent,
-  deleteEvents,
-  setEventDates,
   setEventStartDate,
   setEventEndDate,
+  setEventDates,
+  deleteEvents,
+  modifyEvent,
+  addEvent,
   removeSeededParticipant,
   removeScaleValues,
   checkValidEntries,
@@ -58155,6 +58391,7 @@ const eventGovernor = {
   getAvailablePlayoffProfiles,
   deleteDrawDefinitions,
   addPlayoffStructures,
+  modifyDrawDefinition,
   addDrawDefinition: addDrawDefinition$1,
   removeStructure,
   modifyDrawName,
@@ -58259,9 +58496,9 @@ function getPredictiveAccuracy(params) {
     exclusionRule,
     zoneDoubling,
     matchUpType,
-    zoneMargin,
     scaleName,
     eventId,
+    zonePct,
     drawId,
     event
   } = params;
@@ -58274,6 +58511,8 @@ function getPredictiveAccuracy(params) {
   const scaleProfile = ratingsParameters[scaleName];
   const ascending = scaleProfile?.ascending ?? params.ascending ?? false;
   const valueAccessor = scaleProfile?.accessor ?? params.valueAccessor;
+  const ratingsRangeDifference = Array.isArray(scaleProfile?.range) ? Math.abs(scaleProfile.range[0] - scaleProfile.range[1]) : 0;
+  const zoneMargin = isConvertableInteger(zonePct) && ratingsRangeDifference ? (zonePct || 0 / 100) * ratingsRangeDifference : params.zoneMargin || ratingsRangeDifference;
   const contextProfile = { withScaleValues: true, withCompetitiveness: true };
   const contextFilters = {
     matchUpTypes: matchUpType ? [matchUpType] : [SINGLES$1, DOUBLES$1]
@@ -58311,7 +58550,7 @@ function getPredictiveAccuracy(params) {
   }
   const relevantMatchUps = matchUps.filter(
     ({ winningSide, score, sides, matchUpStatus }) => ![RETIRED$1, DEFAULTED, WALKOVER$2, DEAD_RUBBER, ABANDONED$1].includes(
-      matchUpStatus
+      matchUpStatus || ""
     ) && scoreHasValue({ score }) && sides?.length === 2 && winningSide
   );
   const accuracy = getGroupingAccuracy({
@@ -58322,8 +58561,8 @@ function getPredictiveAccuracy(params) {
     ascending,
     scaleName
   });
-  const marginCalc = !zoneDoubling || matchUpType === SINGLES$1 ? zoneMargin : zoneMargin * 2;
-  const zoneData = zoneMargin && relevantMatchUps.map(({ competitiveProfile, matchUpType: matchUpType2, score, sides }) => {
+  const marginCalc = !zoneDoubling || matchUpType === SINGLES$1 ? zoneMargin : (zoneMargin || 0) * 2;
+  const zoneData = zoneMargin ? relevantMatchUps.map(({ competitiveProfile, matchUpType: matchUpType2, score, sides }) => {
     const sideValues = getSideValues({
       valueAccessor,
       matchUpType: matchUpType2,
@@ -58338,8 +58577,8 @@ function getPredictiveAccuracy(params) {
     };
   }).filter(({ valuesGap }) => {
     return valuesGap <= marginCalc;
-  });
-  const zoneBands = zoneData?.length && getGroupingBands({ zoneData });
+  }) : [];
+  const zoneBands = getGroupingBands({ zoneData });
   const totalZoneMatchUps = zoneBands && [].concat(Object.values(zoneBands)).flat().length;
   const zoneDistribution = totalZoneMatchUps && Object.assign(
     {},
@@ -58490,7 +58729,7 @@ function getGroupingAccuracy({
       continue;
     }
     const valuesGap = sideValues[winningIndex].value - sideValues[1 - winningIndex].value;
-    const floatMargin = parseFloat(excludeMargin);
+    const floatMargin = parseFloat(excludeMargin || 0);
     const excludeGap = floatMargin && Math.abs(valuesGap) < floatMargin;
     if (excludeGap) {
       accuracy.excluded.push({
@@ -60264,7 +60503,7 @@ function generatePersons(params) {
         return false;
       if (typeof person.lastName !== "string")
         return false;
-      if (![MALE, FEMALE].includes(person.sex))
+      if (person.sex && ![MALE, FEMALE].includes(person.sex))
         return false;
       if (person.nationalityCode && (typeof person.nationalityCode !== "string" || person.nationalityCode.length > 3 || !countries.find(
         ({ iso, ioc }) => [iso, ioc].includes(person.nationalityCode)
@@ -60280,7 +60519,7 @@ function generatePersons(params) {
       return { error: INVALID_VALUES };
     }
   }
-  const shuffledPersons = shuffleArray(validPersonData);
+  const shuffledPersons = personData ? validPersonData : shuffleArray(validPersonData);
   if (shuffledPersons.length < count) {
     const {
       maleFirstNames,