tods-competition-factory 2.0.13 → 2.0.14

package/dist/tods-competition-factory.development.cjs.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.0.13';
+    return '2.0.14';
 }
 
 const SUCCESS = { success: true };
@@ -3239,11 +3239,11 @@ function getMinFinishingPositionRange(structure) {
     }, undefined);
 }
 
-function findStructure({ drawDefinition, structureId }) {
-    if (!drawDefinition)
-        return { error: MISSING_DRAW_DEFINITION };
-    if (!structureId)
-        return { error: MISSING_STRUCTURE_ID };
+function findStructure(params) {
+    const paramsCheck = checkRequiredParameters(params, [{ [DRAW_DEFINITION]: true, [STRUCTURE_ID]: true }]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const { drawDefinition, structureId } = params;
     const { structures } = getDrawStructures({ drawDefinition });
     const allStructures = structures
         ?.map((structure) => {
@@ -5127,6 +5127,20 @@ function getCheckedInParticipantIds({ matchUp }) {
     };
 }
 
+const matchUpEventTypeMap = {
+    [SINGLES]: [SINGLES, 'S'],
+    [DOUBLES]: [DOUBLES, 'D'],
+    [TEAM$1]: [TEAM$1, 'T'],
+    S: [SINGLES, 'S'],
+    D: [DOUBLES, 'D'],
+    T: [TEAM$1, 'T'],
+};
+
+const isMatchUpEventType = (type) => (params) => {
+    const matchUpEventType = (isObject(params) && params?.matchUpType) || (isString(params) && params);
+    return matchUpEventType && matchUpEventTypeMap[type].includes(matchUpEventType);
+};
+
 function findMatchupFormatAverageTimes(params) {
     const { matchUpAverageTimes, matchUpFormat } = params || {};
     const codeMatches = matchUpAverageTimes
@@ -5317,7 +5331,7 @@ function matchUpFormatTimes({ timingDetails, eventType }) {
     const recoveryKeys = Object.keys(recoveryTimes?.minutes || {});
     const recoveryMinutes = recoveryTimes?.minutes &&
         ((recoveryKeys?.includes(eventType) && recoveryTimes.minutes[eventType]) || recoveryTimes.minutes.default);
-    const formatChangeKey = eventType === SINGLES_EVENT ? SINGLES_DOUBLES : DOUBLES_SINGLES;
+    const formatChangeKey = isMatchUpEventType(SINGLES_EVENT)(eventType) ? SINGLES_DOUBLES : DOUBLES_SINGLES;
     const typeChangeRecoveryMinutes = recoveryTimes?.minutes &&
         ((recoveryKeys?.includes(formatChangeKey) && recoveryTimes.minutes[formatChangeKey]) || recoveryMinutes);
     return { averageMinutes, recoveryMinutes, typeChangeRecoveryMinutes };
@@ -6601,10 +6615,9 @@ function isAdHoc({ structure }) {
     const matchUps = structure.matchUps || (structure.roundMatchUps && Object.values(structure.roundMatchUps).flat());
     const hasRoundPosition = !!matchUps?.find((matchUp) => matchUp?.roundPosition);
     const hasDrawPosition = !!matchUps?.find((matchUp) => matchUp?.drawPositions?.length);
-    const adHoc = !structure?.structures &&
+    return (!structure?.structures &&
         structure?.stage !== VOLUNTARY_CONSOLATION &&
-        (!matchUps.length || (!hasRoundPosition && !hasDrawPosition));
-    return adHoc;
+        (!matchUps.length || (!hasRoundPosition && !hasDrawPosition)));
 }
 
 const POLICY_ROUND_NAMING_DEFAULT = {
@@ -6722,6 +6735,12 @@ function getMatchUpType(params) {
     return { matchUpType };
 }
 
+function includesMatchUpEventType(types, matchUpEventType) {
+    if (!Array.isArray(types) || !isString(matchUpEventType))
+        return false;
+    return intersection(types, matchUpEventTypeMap[matchUpEventType]).length;
+}
+
 function filterMatchUps(params) {
     const { matchUps, isCollectionMatchUp, excludeMatchUpStatuses, matchUpStatuses, hasWinningSide, matchUpFormats, roundPositions, matchUpFormat, collectionIds, isMatchUpTie, roundNumbers, matchUpIds, roundNames, stageSequences, scheduledDates, scheduledDate, participantIds, processContext, tournamentIds, matchUpTypes, structureIds, readyToScore, courtIds, eventIds, venueIds, drawIds, stages, filterMatchUpIds = true, filterMatchUpTypes = true, } = params;
     const targetParticipantIds = Array.isArray(participantIds) ? participantIds.filter(Boolean) : [];
@@ -6750,7 +6769,7 @@ function filterMatchUps(params) {
     const targetDrawIds = Array.isArray(drawIds) ? drawIds.filter(Boolean) : [];
     const targetStructureIds = Array.isArray(structureIds) ? structureIds.filter(Boolean) : [];
     return matchUps.filter((matchUp) => {
-        if (readyToScore && matchUp.matchUpType !== TEAM_MATCHUP && !matchUp.readyToScore)
+        if (readyToScore && !isMatchUpEventType(TEAM_MATCHUP)(matchUp) && !matchUp.readyToScore)
             return false;
         if (matchUp.winningSide && hasWinningSide && ![1, 2].includes(matchUp.winningSide))
             return false;
@@ -6801,7 +6820,8 @@ function filterMatchUps(params) {
         if (targetMatchUpIds.length && !targetMatchUpIds.includes(matchUp.matchUpId)) {
             return false;
         }
-        if (targetMatchUpTypes.length && (!matchUp.matchUpType || !targetMatchUpTypes.includes(matchUp.matchUpType))) {
+        if (targetMatchUpTypes.length &&
+            (!matchUp.matchUpType || !includesMatchUpEventType(targetMatchUpTypes, matchUp.matchUpType))) {
             return false;
         }
         if (targetMatchUpFormats.length &&
@@ -7319,7 +7339,7 @@ function getAllStructureMatchUps({ scheduleVisibilityFilters, tournamentAppliedP
                 matchUpWithContext.matchUpType !== TEAM$2;
             if (inferGender) {
                 const sideGenders = matchUpWithContext.sides.map((side) => {
-                    if (matchUpWithContext.matchUpType === SINGLES)
+                    if (isMatchUpEventType(SINGLES)(matchUpWithContext.matchUpType))
                         return side.participant?.person?.sex;
                     if (side.participant?.individualParticipants?.length === 2) {
                         const pairGenders = unique(side.participant.individualParticipants.map((participant) => participant.person?.sex)).filter(Boolean);
@@ -11389,6 +11409,11 @@ function getTournamentPublishStatus({ tournamentRecord, status = PUBLIC }) {
     })?.timeItem?.itemValue?.[status];
 }
 
+function isValidTournamentRecord(tournamentRecord) {
+    const { tournamentId } = tournamentRecord ?? {};
+    return !!tournamentId;
+}
+
 function getEventPublishStatus({ event, status = PUBLIC }) {
     const itemType = `${PUBLISH}.${STATUS$1}`;
     return getEventTimeItem({
@@ -11402,29 +11427,28 @@ function getDrawPublishStatus({ drawDetails, drawId }) {
     return details?.published;
 }
 
-function getPublishState({ tournamentRecord, drawDefinition, eventIds, eventId, drawIds, drawId, event, }) {
-    if (eventId && !event) {
+function getPublishState(params) {
+    const { tournamentRecord, drawDefinition, eventIds, eventId, drawIds, drawId, event } = params ?? {};
+    if (tournamentRecord && !isValidTournamentRecord(tournamentRecord))
+        return { error: INVALID_VALUES };
+    if (eventId && !event)
         return { error: EVENT_NOT_FOUND };
-    }
-    else if (Array.isArray(eventIds) && eventIds?.length) {
+    if (Array.isArray(eventIds) && eventIds?.length) {
         const publishState = {};
         for (const eventId of eventIds) {
             if (!isString(eventId))
                 return { error: INVALID_VALUES };
-            const event = findEvent({ tournamentRecord, eventId });
+            const event = findEvent({ tournamentRecord, eventId })?.event;
             if (!event)
                 return { error: EVENT_NOT_FOUND };
             const pubStatus = getPubStatus({ event });
-            if (pubStatus.error)
-                return pubStatus;
             publishState[eventId] = pubStatus;
         }
         return { ...SUCCESS, publishState };
     }
-    else if (event) {
+    if (event) {
         const pubStatus = getPubStatus({ event });
-        if (pubStatus.error)
-            return pubStatus;
+        let publishState = {};
         if (drawId) {
             if (!drawDefinition)
                 return { error: DRAW_DEFINITION_NOT_FOUND };
@@ -11439,47 +11463,38 @@ function getPublishState({ tournamentRecord, drawDefinition, eventIds, eventId,
             };
         }
         else if (Array.isArray(drawIds) && drawIds?.length) {
-            const publishState = {};
+            const eventDrawIds = event.drawDefinitions?.map(getDrawId) || [];
             for (const drawId of drawIds) {
                 if (!isString(drawId))
                     return { error: INVALID_VALUES };
+                if (!eventDrawIds.includes(drawId))
+                    return { error: DRAW_DEFINITION_NOT_FOUND };
                 publishState[drawId] = {
                     status: {
                         published: !!pubStatus.status.publishedDrawIds.includes(drawId),
                         drawDetail: pubStatus.status.drawDetails?.[drawId],
                     },
                 };
-                return { ...SUCCESS, publishState };
             }
         }
         else {
-            return { publishState: pubStatus };
+            publishState = pubStatus;
         }
+        return { ...SUCCESS, publishState };
     }
-    else if (!tournamentRecord) {
-        return { error: MISSING_TOURNAMENT_RECORD };
-    }
-    else {
-        const publishState = {};
-        const pubStatus = getTournamentPublishStatus({ tournamentRecord });
-        publishState.tournament = pubStatus;
-        for (const event of tournamentRecord.events ?? []) {
-            const pubStatus = getPubStatus({ event });
-            publishState[event.eventId] = pubStatus;
-            if (pubStatus.error)
-                return pubStatus;
-            for (const { drawId } of event.drawDefinitions ?? []) {
-                if (!isString(drawId))
-                    return { error: INVALID_VALUES };
-                const published = pubStatus.publishState?.publishedDrawIds?.includes(drawId);
-                if (published) {
-                    publishState[drawId] = { status: { published } };
-                }
-            }
+    const publishState = {};
+    const pubStatus = getTournamentPublishStatus({ tournamentRecord });
+    publishState.tournament = pubStatus;
+    for (const event of tournamentRecord?.events ?? []) {
+        const pubStatus = getPubStatus({ event });
+        publishState[event.eventId] = pubStatus;
+        for (const { drawId } of event.drawDefinitions ?? []) {
+            const published = pubStatus.status?.publishedDrawIds?.includes(drawId);
+            if (published)
+                publishState[drawId] = { status: { published } };
         }
-        return { ...SUCCESS, publishState };
     }
-    return { error: INVALID_VALUES };
+    return { ...SUCCESS, publishState };
 }
 function getPubStatus({ event }) {
     const eventPubStatus = getEventPublishStatus({ event });
@@ -11501,12 +11516,13 @@ function getPubStatus({ event }) {
             };
         }
     }
-    const publishedDrawIds = (drawDetails && Object.keys(drawDetails).filter((drawId) => getDrawPublishStatus({ drawDetails, drawId }))) ||
-        eventPubStatus.drawIds ||
-        [];
+    const publishedDrawIds = (drawDetails &&
+        Object.keys(drawDetails).length &&
+        Object.keys(drawDetails).filter((drawId) => getDrawPublishStatus({ drawDetails, drawId }))) ||
+        eventPubStatus.drawIds;
     return {
         status: {
-            published: publishedDrawIds.length > 0,
+            published: publishedDrawIds && publishedDrawIds.length > 0,
             publishedDrawIds,
             publishedSeeding,
             drawDetails,
@@ -12276,7 +12292,7 @@ function filterParticipants({ participantFilters = {}, tournamentRecord, partici
             .filter((event) => eventIds.includes(event.eventId))
             .map((event) => {
             const enteredParticipantIds = (event.entries || []).map((entry) => entry.participantId);
-            if (event.eventType === SINGLES$1)
+            if (isMatchUpEventType(SINGLES$1)(event.eventType))
                 return enteredParticipantIds;
             const individualParticipantIds = (tournamentRecord?.participants ?? [])
                 .filter((participant) => enteredParticipantIds.includes(participant.participantId))
@@ -12880,7 +12896,9 @@ function addEventEntries(params) {
         ?.filter((participant) => {
         if (!participantIds.includes(participant.participantId))
             return false;
-        const validSingles = event.eventType === SINGLES && participant.participantType === INDIVIDUAL && !isUngrouped(entryStatus);
+        const validSingles = isMatchUpEventType(SINGLES)(event.eventType) &&
+            participant.participantType === INDIVIDUAL &&
+            !isUngrouped(entryStatus);
         const validDoubles = event.eventType === DOUBLES && participant.participantType === PAIR;
         if (validSingles &&
             (!event.gender ||
@@ -19621,11 +19639,11 @@ function getParticipantResults({ participantIds, matchUpFormat, tallyPolicy, per
                             checkInitializeParticipant(participantResults, tieLosingParticipantId);
                             participantResults[tieWinningParticipantId].tieMatchUpsWon += 1;
                             participantResults[tieLosingParticipantId].tieMatchUpsLost += 1;
-                            if (tieMatchUp.matchUpType === SINGLES) {
+                            if (isMatchUpEventType(SINGLES)(tieMatchUp.matchUpType)) {
                                 participantResults[tieWinningParticipantId].tieSinglesWon += 1;
                                 participantResults[tieLosingParticipantId].tieSinglesLost += 1;
                             }
-                            else if (tieMatchUp.matchUpType === DOUBLES) {
+                            else if (isMatchUpEventType(DOUBLES)(tieMatchUp.matchUpType)) {
                                 participantResults[tieWinningParticipantId].tieDoublesWon += 1;
                                 participantResults[tieLosingParticipantId].tieDoublesLost += 1;
                             }
@@ -19655,8 +19673,8 @@ function getParticipantResults({ participantIds, matchUpFormat, tallyPolicy, per
                 perPlayer = 0;
                 for (const tieMatchUp of tieMatchUps) {
                     const { matchUpType } = tieMatchUp;
-                    const isDoubles = matchUpType === DOUBLES;
-                    const isSingles = matchUpType === SINGLES;
+                    const isDoubles = isMatchUpEventType(DOUBLES)(matchUpType);
+                    const isSingles = isMatchUpEventType(SINGLES)(matchUpType);
                     if (tieMatchUp.winningSide) {
                         if (tieMatchUp.winningSide === winningSide) {
                             if (winningParticipantId) {
@@ -20792,6 +20810,102 @@ function tieFormatGenderValidityCheck(params) {
     return { valid: true };
 }
 
+function stringify(matchUpFormatObject, preserveRedundant) {
+    if ((matchUpFormatObject?.bestOf || matchUpFormatObject?.exactly) && matchUpFormatObject?.setFormat) {
+        return getSetFormat(matchUpFormatObject, preserveRedundant);
+    }
+    return undefined;
+}
+function getNumber(formatstring) {
+    return !isNaN(Number(formatstring)) && Number(formatstring);
+}
+function timedSetFormat(matchUpFormatObject) {
+    let value = `T${matchUpFormatObject.minutes}`;
+    if (matchUpFormatObject.based)
+        value += matchUpFormatObject.based;
+    if (matchUpFormatObject.modifier)
+        value += `@${matchUpFormatObject.modifier}`;
+    return value;
+}
+function getSetFormat(matchUpFormatObject, preserveRedundant) {
+    const bestOfValue = getNumber(matchUpFormatObject.bestOf) || undefined;
+    const exactly = getNumber(matchUpFormatObject.exactly) || undefined;
+    const setLimit = bestOfValue || exactly;
+    if (matchUpFormatObject.setFormat?.timed && matchUpFormatObject.simplified && setLimit === 1) {
+        return timedSetFormat(matchUpFormatObject.setFormat);
+    }
+    const setLimitCode = (setLimit && `${SET}${setLimit}`) || '';
+    const setCountValue = stringifySet(matchUpFormatObject.setFormat, preserveRedundant);
+    const setCode = (setCountValue && `S:${setCountValue}`) || '';
+    const finalSetCountValue = stringifySet(matchUpFormatObject.finalSetFormat, preserveRedundant);
+    const finalSetCode = (setLimit &&
+        setLimit > 1 &&
+        finalSetCountValue &&
+        setCountValue !== finalSetCountValue &&
+        `F:${finalSetCountValue}`) ||
+        '';
+    const valid = setLimitCode && setCountValue;
+    if (valid) {
+        return [setLimitCode, setCode, finalSetCode].filter((f) => f).join('-');
+    }
+    return undefined;
+}
+function stringifySet(setObject, preserveRedundant) {
+    if (typeof setObject === 'object' && Object.keys(setObject).length) {
+        if (setObject.timed)
+            return timedSetFormat(setObject);
+        if (setObject.tiebreakSet)
+            return tiebreakFormat(setObject.tiebreakSet);
+        const setToValue = getNumber(setObject.setTo);
+        if (setToValue) {
+            const NoAD = (setObject.NoAD && NOAD) || '';
+            const setTiebreakValue = tiebreakFormat(setObject.tiebreakFormat);
+            const setTiebreakCode = (setTiebreakValue && `/${setTiebreakValue}`) || '';
+            const tiebreakAtValue = getNumber(setObject.tiebreakAt);
+            const tiebreakAtCode = (tiebreakAtValue && (tiebreakAtValue !== setToValue || preserveRedundant) && `@${tiebreakAtValue}`) || '';
+            if (setTiebreakValue !== false) {
+                return `${setToValue}${NoAD}${setTiebreakCode}${tiebreakAtCode}`;
+            }
+        }
+    }
+    return undefined;
+}
+function tiebreakFormat(tieobject) {
+    if (tieobject) {
+        if (typeof tieobject === 'object' && !tieobject.tiebreakTo) {
+            return '';
+        }
+        else if (typeof tieobject === 'object' && getNumber(tieobject.tiebreakTo)) {
+            let value = `TB${tieobject.tiebreakTo}${tieobject.NoAD ? NOAD : ''}`;
+            if (tieobject.modifier)
+                value += `@${tieobject.modifier}`;
+            return value;
+        }
+        else {
+            return false;
+        }
+    }
+    return undefined;
+}
+
+function isValidMatchUpFormat({ matchUpFormat }) {
+    if (typeof matchUpFormat !== 'string')
+        return false;
+    const parsedFormat = parse(matchUpFormat);
+    const setParts = matchUpFormat.match(/-S:([1-9])+\/TB([0-9]{1,2})@?([1-9]?)*/);
+    const setsTo = setParts?.[1];
+    const tiebreakTo = setParts?.[2];
+    const tiebreakAt = setParts?.[3];
+    const finalSetParts = matchUpFormat.match(/-F:([1-9])+\/TB([0-9]{1,2})@?([1-9]?)*/);
+    const finalSetTo = finalSetParts?.[1];
+    const finalSetTiebreakTo = finalSetParts?.[2];
+    const finalTiebreakAt = finalSetParts?.[3];
+    const preserveRedundant = !!((setParts && tiebreakTo && setsTo === tiebreakAt) ||
+        (finalSetParts && finalSetTiebreakTo && finalSetTo === finalTiebreakAt));
+    const stringified = stringify(parsedFormat, preserveRedundant);
+    return stringified === matchUpFormat;
+}
+
 const typeMatch = (arr, type) => arr.filter(Boolean).every((i) => typeof i === type);
 const allNumeric = (arr) => arr.filter(Boolean).every(isNumeric);
 function getCategoryAgeDetails(params) {
@@ -21038,102 +21152,6 @@ function categoryCanContain({ childCategory, withDetails, category }) {
     return result;
 }
 
-function stringify(matchUpFormatObject, preserveRedundant) {
-    if ((matchUpFormatObject?.bestOf || matchUpFormatObject?.exactly) && matchUpFormatObject?.setFormat) {
-        return getSetFormat(matchUpFormatObject, preserveRedundant);
-    }
-    return undefined;
-}
-function getNumber(formatstring) {
-    return !isNaN(Number(formatstring)) && Number(formatstring);
-}
-function timedSetFormat(matchUpFormatObject) {
-    let value = `T${matchUpFormatObject.minutes}`;
-    if (matchUpFormatObject.based)
-        value += matchUpFormatObject.based;
-    if (matchUpFormatObject.modifier)
-        value += `@${matchUpFormatObject.modifier}`;
-    return value;
-}
-function getSetFormat(matchUpFormatObject, preserveRedundant) {
-    const bestOfValue = getNumber(matchUpFormatObject.bestOf) || undefined;
-    const exactly = getNumber(matchUpFormatObject.exactly) || undefined;
-    const setLimit = bestOfValue || exactly;
-    if (matchUpFormatObject.setFormat?.timed && matchUpFormatObject.simplified && setLimit === 1) {
-        return timedSetFormat(matchUpFormatObject.setFormat);
-    }
-    const setLimitCode = (setLimit && `${SET}${setLimit}`) || '';
-    const setCountValue = stringifySet(matchUpFormatObject.setFormat, preserveRedundant);
-    const setCode = (setCountValue && `S:${setCountValue}`) || '';
-    const finalSetCountValue = stringifySet(matchUpFormatObject.finalSetFormat, preserveRedundant);
-    const finalSetCode = (setLimit &&
-        setLimit > 1 &&
-        finalSetCountValue &&
-        setCountValue !== finalSetCountValue &&
-        `F:${finalSetCountValue}`) ||
-        '';
-    const valid = setLimitCode && setCountValue;
-    if (valid) {
-        return [setLimitCode, setCode, finalSetCode].filter((f) => f).join('-');
-    }
-    return undefined;
-}
-function stringifySet(setObject, preserveRedundant) {
-    if (typeof setObject === 'object' && Object.keys(setObject).length) {
-        if (setObject.timed)
-            return timedSetFormat(setObject);
-        if (setObject.tiebreakSet)
-            return tiebreakFormat(setObject.tiebreakSet);
-        const setToValue = getNumber(setObject.setTo);
-        if (setToValue) {
-            const NoAD = (setObject.NoAD && NOAD) || '';
-            const setTiebreakValue = tiebreakFormat(setObject.tiebreakFormat);
-            const setTiebreakCode = (setTiebreakValue && `/${setTiebreakValue}`) || '';
-            const tiebreakAtValue = getNumber(setObject.tiebreakAt);
-            const tiebreakAtCode = (tiebreakAtValue && (tiebreakAtValue !== setToValue || preserveRedundant) && `@${tiebreakAtValue}`) || '';
-            if (setTiebreakValue !== false) {
-                return `${setToValue}${NoAD}${setTiebreakCode}${tiebreakAtCode}`;
-            }
-        }
-    }
-    return undefined;
-}
-function tiebreakFormat(tieobject) {
-    if (tieobject) {
-        if (typeof tieobject === 'object' && !tieobject.tiebreakTo) {
-            return '';
-        }
-        else if (typeof tieobject === 'object' && getNumber(tieobject.tiebreakTo)) {
-            let value = `TB${tieobject.tiebreakTo}${tieobject.NoAD ? NOAD : ''}`;
-            if (tieobject.modifier)
-                value += `@${tieobject.modifier}`;
-            return value;
-        }
-        else {
-            return false;
-        }
-    }
-    return undefined;
-}
-
-function isValidMatchUpFormat({ matchUpFormat }) {
-    if (typeof matchUpFormat !== 'string')
-        return false;
-    const parsedFormat = parse(matchUpFormat);
-    const setParts = matchUpFormat.match(/-S:([1-9])+\/TB([0-9]{1,2})@?([1-9]?)*/);
-    const setsTo = setParts?.[1];
-    const tiebreakTo = setParts?.[2];
-    const tiebreakAt = setParts?.[3];
-    const finalSetParts = matchUpFormat.match(/-F:([1-9])+\/TB([0-9]{1,2})@?([1-9]?)*/);
-    const finalSetTo = finalSetParts?.[1];
-    const finalSetTiebreakTo = finalSetParts?.[2];
-    const finalTiebreakAt = finalSetParts?.[3];
-    const preserveRedundant = !!((setParts && tiebreakTo && setsTo === tiebreakAt) ||
-        (finalSetParts && finalSetTiebreakTo && finalSetTo === finalTiebreakAt));
-    const stringified = stringify(parsedFormat, preserveRedundant);
-    return stringified === matchUpFormat;
-}
-
 function validateCollectionDefinition({ checkCategory = true, collectionDefinition, checkCollectionIds, checkGender = true, referenceCategory, referenceGender, event, }) {
     referenceGender = referenceGender ?? event?.gender;
     const stack = 'validateCollectionDefinition';
@@ -21149,7 +21167,7 @@ function validateCollectionDefinition({ checkCategory = true, collectionDefiniti
     if (typeof matchUpCount !== 'number') {
         errors.push(`matchUpCount is not type number: ${matchUpCount}`);
     }
-    if (matchUpType && ![SINGLES, DOUBLES].includes(matchUpType)) {
+    if (matchUpType && !includesMatchUpEventType([SINGLES, DOUBLES], matchUpType)) {
         errors.push(`matchUpType must be SINGLES or DOUBLES: ${matchUpType}`);
     }
     const valueDeclarations = [!!collectionValueProfiles?.length]
@@ -24191,11 +24209,11 @@ function collectionMatchUpActions({ specifiedPolicyDefinitions, inContextDrawMat
             sideNumber: i + 1,
         }));
     const assignmentAvailable = (sideNumber &&
-        ((matchUpType === SINGLES_MATCHUP && !existingParticipantIds?.length) ||
-            (matchUpType === DOUBLES_MATCHUP && (existingParticipantIds?.length ?? 0) < 2))) ||
+        ((isMatchUpEventType(SINGLES_MATCHUP)(matchUpType) && !existingParticipantIds?.length) ||
+            (isMatchUpEventType(DOUBLES_MATCHUP)(matchUpType) && (existingParticipantIds?.length ?? 0) < 2))) ||
         (!sideNumber &&
-            ((matchUpType === SINGLES_MATCHUP && (existingParticipantIds?.length ?? 0) < 2) ||
-                (matchUpType === DOUBLES_MATCHUP && (existingParticipantIds?.length ?? 0) < 4)));
+            ((isMatchUpEventType(SINGLES_MATCHUP)(matchUpType) && (existingParticipantIds?.length ?? 0) < 2) ||
+                (isMatchUpEventType(DOUBLES_MATCHUP)(matchUpType) && (existingParticipantIds?.length ?? 0) < 4)));
     const availableIds = availableParticipantIds?.filter((id) => !allParticipantIds?.includes(id));
     const available = availableParticipants?.filter(({ participantId }) => availableIds.includes(participantId));
     if (assignmentAvailable && availableIds?.length) {
@@ -28768,7 +28786,7 @@ function getPredictiveAccuracy(params) {
         ascending,
         scaleName,
     });
-    const marginCalc = !zoneDoubling || matchUpType === SINGLES ? zoneMargin : (zoneMargin || 0) * 2;
+    const marginCalc = !zoneDoubling || isMatchUpEventType(SINGLES)(matchUpType) ? zoneMargin : (zoneMargin || 0) * 2;
     const zoneData = zoneMargin
         ? relevantMatchUps
             .map(({ competitiveProfile, matchUpType, score, sides }) => {
@@ -35540,22 +35558,22 @@ function setMatchUpMatchUpFormat(params) {
         });
         if (result.error)
             return result;
-        if (!result.matchUp)
-            return { error: MATCHUP_NOT_FOUND };
         const matchUp = result.matchUp;
         if (matchUp?.matchUpType === TEAM$2)
             return {
-                error: INVALID_MATCHUP,
                 info: 'Cannot set matchUpFormat when { matchUpType: TEAM }',
+                error: INVALID_MATCHUP,
             };
-        matchUp.matchUpFormat = matchUpFormat;
-        modifyMatchUpNotice({
-            tournamentId: tournamentRecord?.tournamentId,
-            eventId: event?.eventId,
-            context: stack,
-            drawDefinition,
-            matchUp,
-        });
+        if (matchUp) {
+            matchUp.matchUpFormat = matchUpFormat;
+            modifyMatchUpNotice({
+                tournamentId: tournamentRecord?.tournamentId,
+                eventId: event?.eventId,
+                context: stack,
+                drawDefinition,
+                matchUp,
+            });
+        }
     }
     else if (Array.isArray(structureIds)) {
         if (event?.eventType === TEAM$2)
@@ -35564,12 +35582,8 @@ function setMatchUpMatchUpFormat(params) {
             const result = findStructure({ drawDefinition, structureId });
             if (result.error)
                 return result;
-            if (!result.structure) {
-                return { error: STRUCTURE_NOT_FOUND };
-            }
-            else {
+            if (result.structure)
                 result.structure.matchUpFormat = matchUpFormat;
-            }
         }
     }
     else if (structureId) {
@@ -35578,12 +35592,8 @@ function setMatchUpMatchUpFormat(params) {
         const result = findStructure({ drawDefinition, structureId });
         if (result.error)
             return result;
-        if (!result.structure) {
-            return { error: STRUCTURE_NOT_FOUND };
-        }
-        else {
+        if (result.structure)
             result.structure.matchUpFormat = matchUpFormat;
-        }
     }
     else if (drawDefinition) {
         drawDefinition.matchUpFormat = matchUpFormat;
@@ -38690,7 +38700,7 @@ function generateLineUps(params) {
         for (const collectionDefinition of collectionDefinitions) {
             const collectionParticipantIds = [];
             const { collectionId, matchUpCount, matchUpType, gender } = collectionDefinition;
-            const singlesMatchUp = matchUpType === SINGLES_MATCHUP;
+            const singlesMatchUp = isMatchUpEventType(SINGLES_MATCHUP)(matchUpType);
             generateRange(0, matchUpCount).forEach((i) => {
                 const typeSort = singlesMatchUp ? singlesSort : doublesSort ?? [];
                 const collectionPosition = i + 1;
@@ -39409,7 +39419,7 @@ function getTieMatchUpContext({ tournamentRecord, drawDefinition, tieMatchUpId,
     if (!inContextTieMatchUp)
         return { error: MATCHUP_NOT_FOUND };
     const { collectionPosition, drawPositions, collectionId, matchUpTieId, matchUpType } = inContextTieMatchUp;
-    if (matchUpType && ![SINGLES, DOUBLES].includes(matchUpType))
+    if (matchUpType && !includesMatchUpEventType([SINGLES, DOUBLES], matchUpType))
         return { error: INVALID_MATCHUP };
     const { positionAssignments } = getPositionAssignments$1({ structure });
     const relevantAssignments = positionAssignments?.filter((assignment) => drawPositions?.includes(assignment.drawPosition));
@@ -39957,7 +39967,7 @@ function assignTieMatchUpParticipantId(params) {
         return { error: INVALID_PARTICIPANT, info: 'Gender mismatch' };
     }
     const { individualParticipantIds, participantType } = participantToAssign;
-    if (matchUpType === SINGLES && participantType !== INDIVIDUAL) {
+    if (isMatchUpEventType(SINGLES)(matchUpType) && participantType !== INDIVIDUAL) {
         return { error: INVALID_PARTICIPANT_TYPE };
     }
     const relevantParticipantIds = participantType === INDIVIDUAL ? [participantId] : individualParticipantIds;
@@ -42780,22 +42790,23 @@ function disableTieAutoCalc({ drawDefinition, matchUpId, event }) {
 
 function setMatchUpFormat(params) {
     const stack = 'setMatchUpFormat';
+    const paramsCheck = checkRequiredParameters(params, [
+        { tournamentRecord: true },
+        {
+            [VALIDATE]: (value) => isValidMatchUpFormat({ matchUpFormat: value }),
+            [INVALID]: UNRECOGNIZED_MATCHUP_FORMAT,
+            matchUpFormat: true,
+        },
+    ]);
+    if (paramsCheck.error)
+        return decorateResult({ result: paramsCheck, stack });
     const { tournamentRecord, drawDefinition, scheduledDates, stageSequences, matchUpFormat, structureId, eventType, matchUpId, eventId, stages, drawId, event, force, } = params;
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    if (!matchUpFormat)
-        return { error: MISSING_MATCHUP_FORMAT };
-    if (matchUpFormat && !isValidMatchUpFormat({ matchUpFormat }))
-        return decorateResult({
-            result: { error: UNRECOGNIZED_MATCHUP_FORMAT, matchUpFormat },
-            stack,
-        });
     if (scheduledDates && !Array.isArray(scheduledDates))
         return decorateResult({
             result: { error: INVALID_VALUES, scheduledDates },
             stack,
         });
-    if (eventType && ![SINGLES$1, DOUBLES$1].includes(eventType))
+    if (eventType && !includesMatchUpEventType([SINGLES$1, DOUBLES$1], eventType))
         return decorateResult({ result: { error: INVALID_EVENT_TYPE }, stack });
     let modificationsCount = 0;
     const structureIds = params.structureIds || (structureId && [structureId].filter(Boolean)) || [];
@@ -42867,7 +42878,7 @@ function setMatchUpFormat(params) {
         }
         return modifiedStructureIds;
     };
-    for (const event of tournamentRecord.events || []) {
+    for (const event of tournamentRecord?.events || []) {
         if ((eventIds?.length && !eventIds.includes(event.eventId)) ||
             (eventType && eventType !== event.eventType) ||
             eventType === TEAM$2) {
@@ -43317,7 +43328,7 @@ function applyLineUps({ tournamentRecord, drawDefinition, matchUpId, lineUps, ev
                     collectionParticipantIds[aggregator] = [];
                 }
                 const participantsCount = collectionParticipantIds[aggregator].length;
-                if ((collectionDefinition.matchUpType === SINGLES && participantsCount) ||
+                if ((isMatchUpEventType(SINGLES)(collectionDefinition.matchUpType) && participantsCount) ||
                     (collectionDefinition.matchUpType === DOUBLES && participantsCount > 1)) {
                     return {
                         info: 'Excessive collectionPosition assignments',
@@ -44339,8 +44350,8 @@ function checkRecoveryTime({ individualParticipantProfiles, matchUpNotBeforeTime
 }
 
 function checkDailyLimits({ individualParticipantProfiles, matchUpPotentialParticipantIds, matchUpDailyLimits = {}, matchUp, }) {
-    const { matchUpId, matchUpType } = matchUp;
     const { enteredIndividualParticipantIds } = getIndividualParticipantIds(matchUp);
+    const { matchUpId, matchUpType } = matchUp;
     const potentialParticipantIds = ((matchUp.roundPosition && matchUpPotentialParticipantIds[matchUpId]) || []).flat();
     const relevantParticipantIds = unique(enteredIndividualParticipantIds.concat(...potentialParticipantIds));
     relevantParticipantIds.forEach((participantId) => {
@@ -46514,12 +46525,12 @@ function processTieFormat({ alternatesCount = 0, tieFormatName, tieFormat, drawS
         }
         if (!collectionId)
             collectionDefinition.collectionId = UUID();
-        if (matchUpType === DOUBLES) {
+        if (isMatchUpEventType(DOUBLES)(matchUpType)) {
             const doublesCount = matchUpCount;
             doublesMatchUpTotal += matchUpCount;
             maxDoublesCount = Math.max(maxDoublesCount, doublesCount);
         }
-        if (matchUpType === SINGLES) {
+        if (isMatchUpEventType(SINGLES)(matchUpType)) {
             const singlescount = matchUpCount;
             singlesMatchUpTotal += matchUpCount;
             maxSinglesCount = Math.max(maxSinglesCount, singlescount);
@@ -47470,8 +47481,8 @@ function completeDrawMatchUps(params) {
                     tournamentRecord,
                 });
                 const assignParticipants = (dualMatchUp) => {
-                    const singlesMatchUps = dualMatchUp.tieMatchUps.filter(({ matchUpType }) => matchUpType === SINGLES);
-                    const doublesMatchUps = dualMatchUp.tieMatchUps.filter(({ matchUpType }) => matchUpType === DOUBLES);
+                    const singlesMatchUps = dualMatchUp.tieMatchUps.filter(isMatchUpEventType(SINGLES));
+                    const doublesMatchUps = dualMatchUp.tieMatchUps.filter(isMatchUpEventType(DOUBLES));
                     singlesMatchUps.forEach((singlesMatchUp, i) => {
                         const tieMatchUpId = singlesMatchUp.matchUpId;
                         singlesMatchUp.sides.forEach((side) => {
@@ -47757,7 +47768,9 @@ function generateFlightDrawDefinitions({ matchUpStatusProfile, completeAllMatchU
 function generateEventParticipants(params) {
     const { participantsProfile = {}, uniqueParticipantsCount, ratingsParameters, tournamentRecord, eventProfile, eventIndex, event, uuids, } = params;
     const { category, gender, eventType } = event;
-    const eventParticipantType = (eventType === SINGLES$1 && INDIVIDUAL) || (eventType === DOUBLES$1 && PAIR) || eventType;
+    const eventParticipantType = (isMatchUpEventType(SINGLES$1)(eventType) && INDIVIDUAL) ||
+        (isMatchUpEventType(DOUBLES$1)(eventType) && PAIR) ||
+        eventType;
     const mainParticipantsCount = uniqueParticipantsCount[MAIN] || 0;
     const qualifyingParticipantsCount = uniqueParticipantsCount[QUALIFYING] || 0;
     const participantsCount = eventProfile.drawProfiles?.length
@@ -47873,7 +47886,9 @@ function generateEventWithFlights(params) {
         category,
         gender,
     });
-    const eventParticipantType = (eventType === SINGLES$1 && INDIVIDUAL) || (eventType === DOUBLES$1 && PAIR) || eventType;
+    const eventParticipantType = (isMatchUpEventType(SINGLES$1)(eventType) && INDIVIDUAL) ||
+        (isMatchUpEventType(DOUBLES$1)(eventType) && PAIR) ||
+        eventType;
     const { uniqueDrawParticipants = [], uniqueParticipantIds = [] } = uniqueParticipantStages
         ? generateEventParticipants({
             event: { eventType, category, gender },
@@ -48233,9 +48248,9 @@ function generateEventWithDraw(params) {
     }
     const isEventParticipantType = (participant) => {
         const { participantType } = participant;
-        if (eventType === SINGLES$1 && participantType === INDIVIDUAL)
+        if (isMatchUpEventType(SINGLES$1)(eventType) && participantType === INDIVIDUAL)
             return true;
-        if (eventType === DOUBLES$1 && participantType === PAIR)
+        if (isMatchUpEventType(DOUBLES$1)(eventType) && participantType === PAIR)
             return true;
         return eventType === TEAM && participantType === TEAM;
     };
@@ -48987,7 +49002,9 @@ function modifyTournamentRecord(params) {
             else {
                 const { gender, category, eventType } = event;
                 const { drawProfiles, publish } = eventProfile;
-                const eventParticipantType = (eventType === SINGLES$1 && INDIVIDUAL) || (eventType === DOUBLES$1 && PAIR) || eventType;
+                const eventParticipantType = (isMatchUpEventType(SINGLES$1)(eventType) && INDIVIDUAL) ||
+                    (isMatchUpEventType(DOUBLES$1)(eventType) && PAIR) ||
+                    eventType;
                 if (drawProfiles) {
                     const { stageParticipantsCount, uniqueParticipantsCount, uniqueParticipantStages } = getStageParticipantsCount({
                         drawProfiles,
@@ -54947,9 +54964,11 @@ function venueModify({ tournamentRecord, modifications, venueId, force }) {
         validReplacementAttributes.forEach((attribute) => Object.assign(venue, { [attribute]: modifications[attribute] }));
     const existingCourtIds = venue?.courts?.map((court) => court.courtId) ?? [];
     const courtIdsToModify = modifications.courts?.map((court) => court.courtId) || [];
-    const courtIdsToDelete = courtIdsToModify.length && existingCourtIds.filter((courtId) => !courtIdsToModify.includes(courtId));
+    const courtIdsToDelete = courtIdsToModify.length
+        ? existingCourtIds.filter((courtId) => !courtIdsToModify.includes(courtId))
+        : modifications?.courts && existingCourtIds;
     const matchUpsWithCourtId = [];
-    if (courtIdsToDelete.length) {
+    if (courtIdsToDelete?.length) {
         const courtsToDelete = venue?.courts?.filter((court) => courtIdsToDelete.includes(court.courtId));
         const scheduleDeletionsCount = courtsToDelete
             ?.map((court) => {
@@ -55372,60 +55391,6 @@ var index$1 = {
 
 const forge = {};
 
-function notifySubscribers(params) {
-    const { mutationStatus, tournamentId, directives, timeStamp } = params || {};
-    const { topics } = getTopics();
-    for (const topic of [...topics].sort(topicSort)) {
-        const notices = getNotices({ topic });
-        if (notices)
-            callListener({ topic, notices });
-    }
-    if (mutationStatus && timeStamp && topics.includes(MUTATIONS)) {
-        callListener({
-            notices: [{ tournamentId, directives, timeStamp }],
-            topic: MUTATIONS,
-        });
-    }
-}
-async function notifySubscribersAsync(params) {
-    const { mutationStatus, tournamentId, directives, timeStamp } = params || {};
-    const { topics } = getTopics();
-    for (const topic of [...topics].sort(topicSort)) {
-        const notices = getNotices({ topic });
-        if (notices)
-            await callListener({ topic, notices });
-    }
-    if (mutationStatus && timeStamp && topics.includes(MUTATIONS)) {
-        callListener({
-            notices: [{ tournamentId, directives, timeStamp }],
-            topic: MUTATIONS,
-        });
-    }
-}
-const topicValues = {
-    [UNPUBLISH_EVENT_SEEDING]: 5,
-    [UNPUBLISH_EVENT]: 5,
-    [UNPUBLISH_ORDER_OF_PLAY]: 5,
-    [MODIFY_SEED_ASSIGNMENTS]: 5,
-    [MODIFY_POSITION_ASSIGNMENTS]: 5,
-    [MODIFY_DRAW_DEFINITION]: 5,
-    [MODIFY_DRAW_ENTRIES]: 5,
-    [MODIFY_EVENT_ENTRIES]: 5,
-    [MODIFY_MATCHUP]: 1,
-    [UPDATE_INCONTEXT_MATCHUP]: 1,
-    [MODIFY_PARTICIPANTS]: 5,
-    [MODIFY_VENUE]: 5,
-    [DELETED_MATCHUP_IDS]: 4,
-    [DELETE_PARTICIPANTS]: 4,
-    [DELETE_VENUE]: 4,
-    [DELETED_DRAW_IDS]: 4,
-    [ADD_MATCHUPS]: 3,
-    [ADD_DRAW_DEFINITION]: 2,
-};
-function topicSort(a, b) {
-    return (topicValues[b] || 0) - (topicValues[a] || 0);
-}
-
 const { FACTORY } = extensionConstants;
 function updateFactoryExtension({ tournamentRecord, value }) {
     const { extension } = findExtension({
@@ -55591,6 +55556,60 @@ function invoke({ tournamentRecords, tournamentRecord, params, methodName, metho
     }
 }
 
+function notifySubscribers(params) {
+    const { mutationStatus, tournamentId, directives, timeStamp } = params || {};
+    const { topics } = getTopics();
+    for (const topic of [...topics].sort(topicSort)) {
+        const notices = getNotices({ topic });
+        if (notices)
+            callListener({ topic, notices });
+    }
+    if (mutationStatus && timeStamp && topics.includes(MUTATIONS)) {
+        callListener({
+            notices: [{ tournamentId, directives, timeStamp }],
+            topic: MUTATIONS,
+        });
+    }
+}
+async function notifySubscribersAsync(params) {
+    const { mutationStatus, tournamentId, directives, timeStamp } = params || {};
+    const { topics } = getTopics();
+    for (const topic of [...topics].sort(topicSort)) {
+        const notices = getNotices({ topic });
+        if (notices)
+            await callListener({ topic, notices });
+    }
+    if (mutationStatus && timeStamp && topics.includes(MUTATIONS)) {
+        callListener({
+            notices: [{ tournamentId, directives, timeStamp }],
+            topic: MUTATIONS,
+        });
+    }
+}
+const topicValues = {
+    [UNPUBLISH_EVENT_SEEDING]: 5,
+    [UNPUBLISH_EVENT]: 5,
+    [UNPUBLISH_ORDER_OF_PLAY]: 5,
+    [MODIFY_SEED_ASSIGNMENTS]: 5,
+    [MODIFY_POSITION_ASSIGNMENTS]: 5,
+    [MODIFY_DRAW_DEFINITION]: 5,
+    [MODIFY_DRAW_ENTRIES]: 5,
+    [MODIFY_EVENT_ENTRIES]: 5,
+    [MODIFY_MATCHUP]: 1,
+    [UPDATE_INCONTEXT_MATCHUP]: 1,
+    [MODIFY_PARTICIPANTS]: 5,
+    [MODIFY_VENUE]: 5,
+    [DELETED_MATCHUP_IDS]: 4,
+    [DELETE_PARTICIPANTS]: 4,
+    [DELETE_VENUE]: 4,
+    [DELETED_DRAW_IDS]: 4,
+    [ADD_MATCHUPS]: 3,
+    [ADD_DRAW_DEFINITION]: 2,
+};
+function topicSort(a, b) {
+    return (topicValues[b] || 0) - (topicValues[a] || 0);
+}
+
 function getState$1({ convertExtensions, removeExtensions }) {
     const tournamentRecords = getTournamentRecords();
     const tournamentId = getTournamentId();