tods-competition-factory 2.0.59 → 2.1.0

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.0.59';
+    return '2.1.0';
 }
 
 function isFunction(obj) {
@@ -46,7 +46,7 @@ const hasAttributeValues = (a) => (o) => Object.keys(a).every((key) => o[key] ==
 function undefinedToNull(obj, shallow) {
     if (obj === undefined)
         return null;
-    if (typeof obj !== 'object' || obj === null)
+    if (!isObject(obj) || obj === null)
         return obj;
     const definedKeys = Object.keys(obj);
     const notNull = (value) => (value === undefined ? null : value);
@@ -62,7 +62,7 @@ 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) {
+    else if (isObject(o) && o !== null) {
         return (Object.keys(o).length +
             Object.keys(o)
                 .map((k) => countKeys(o[k]))
@@ -446,6 +446,10 @@ const MISSING_VALUE = {
     message: 'Missing value',
     code: 'ERR_MISSING_VALUE',
 };
+const MISSING_BIRTH_DATE = {
+    message: 'Missing birthdate',
+    code: 'ERR_MISSING_BIRTH_DATE',
+};
 const MISSING_DATE = {
     message: 'Missing date',
     code: 'ERR_MISSING_DATE',
@@ -506,6 +510,10 @@ const CANNOT_REMOVE_PARTICIPANTS = {
     message: 'Cannot remove participants',
     code: 'ERR_UNCHANGED_CANNOT_REMOVE_PARTICIPANTS',
 };
+const CATEGORY_MISMATCH = {
+    message: 'Participant category mismatch',
+    code: 'ERR_CATEGORY_MISMATCH',
+};
 const CANNOT_CHANGE_WINNING_SIDE = {
     message: 'Cannot change winningSide',
     code: 'ERR_UNCHANGED_CANNOT_CHANGE_WINNING_SIDE',
@@ -818,6 +826,7 @@ const errorConditionConstants = {
     CANNOT_MODIFY_PARTICIPANT_TYPE,
     CANNOT_REMOVE_MAIN_STRUCTURE,
     CANNOT_REMOVE_PARTICIPANTS,
+    CATEGORY_MISMATCH,
     COURT_EXISTS,
     COURT_NOT_FOUND,
     DRAW_DEFINITION_NOT_FOUND,
@@ -900,6 +909,7 @@ const errorConditionConstants = {
     MISSING_ASSIGNMENTS,
     MISSING_ASYNC_STATE_PROVIDER,
     MISSING_AVOIDANCE_POLICY,
+    MISSING_BIRTH_DATE,
     MISSING_COLLECTION_DEFINITION,
     MISSING_COURT_ID,
     MISSING_COURTS_INFO,
@@ -3414,9 +3424,11 @@ const MUTATIONS = 'mutations';
 const PUBLISH_EVENT = 'publishEvent';
 const PUBLISH_EVENT_SEEDING = 'publishEventSeeding';
 const PUBLISH_ORDER_OF_PLAY = 'publishOrderOfPlay';
+const PUBLISH_PARTICIPANTS = 'publishParticipants';
 const UNPUBLISH_EVENT = 'unPublishEvent';
 const UNPUBLISH_EVENT_SEEDING = 'unPublishEventSeeding';
 const UNPUBLISH_ORDER_OF_PLAY = 'unPublishOrderOfPlay';
+const UNPUBLISH_PARTICIPANTS = 'unPublishParticipants';
 const UPDATE_INCONTEXT_MATCHUP = 'updateInContextMatchUp';
 const topicConstants = {
     ADD_DRAW_DEFINITION,
@@ -3443,6 +3455,7 @@ const topicConstants = {
     PUBLISH_EVENT_SEEDING,
     PUBLISH_EVENT,
     PUBLISH_ORDER_OF_PLAY,
+    PUBLISH_PARTICIPANTS,
     UNPUBLISH_EVENT_SEEDING,
     UNPUBLISH_EVENT,
     UNPUBLISH_ORDER_OF_PLAY,
@@ -11537,12 +11550,16 @@ function addScheduleItem(params) {
     }
 }
 
-function getTournamentPublishStatus({ tournamentRecord, status = PUBLIC }) {
+function getTournamentPublishStatus(params) {
+    const paramsCheck = checkRequiredParameters(params, [{ [TOURNAMENT_RECORD]: true }]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const { tournamentRecord, status = PUBLIC } = params;
     const itemType = `${PUBLISH}.${STATUS$1}`;
-    return getTournamentTimeItem({
+    return makeDeepCopy(getTournamentTimeItem({
         tournamentRecord,
         itemType,
-    })?.timeItem?.itemValue?.[status];
+    })?.timeItem?.itemValue?.[status], false, true);
 }
 
 function isValidTournamentRecord(tournamentRecord) {
@@ -11637,6 +11654,8 @@ function getPublishState(params) {
     if (tournamentRecord) {
         const pubStatus = getTournamentPublishStatus({ tournamentRecord });
         publishState.tournament = pubStatus ?? {};
+        if (pubStatus?.orderOfPlay?.published || pubStatus?.participants?.published)
+            tournamentPublished = true;
         publishState.tournament.status = { published: tournamentPublished, publishedEventIds };
     }
     return { ...SUCCESS, publishState };
@@ -20613,12 +20632,12 @@ const headToHeadTallyDirectives = [
 const GEMScoreValueMap = {
     matchUpsPct: 20,
     tieMatchUpsPct: 16,
-    setsPct: 12,
-    gamesPct: 8,
     pointsPct: 4,
+    gamesPct: 8,
+    setsPct: 12,
 };
 function getGroupOrder(params) {
-    const { requireCompletion = true, participantResults, subOrderMap, tallyPolicy } = params;
+    const { requireCompletion = true, participantResults, subOrderMap, tallyPolicy, } = params;
     const report = [];
     if (requireCompletion && !isComplete(params)) {
         return {};
@@ -20643,16 +20662,20 @@ function getGroupOrder(params) {
         attribute,
     });
     report.push({ attribute, groups: orderedTallyGroups });
-    const groupOrder = Object.keys(orderedTallyGroups)
+    const sortedTallyGroups = Object.keys(orderedTallyGroups)
         .map((key) => parseFloat(key))
         .sort((a, b) => b - a)
-        .map((key) => orderedTallyGroups[key])
-        .map((participantIds) => {
+        .map((key) => orderedTallyGroups[key]);
+    const sortedOrder = sortedTallyGroups.map((participantIds) => {
         const result = groupSubSort({ participantIds, ...params });
         report.push(...(result.report ?? []));
         return result.order;
-    })
-        .flat(Infinity);
+    });
+    const groupOrder = sortedOrder
+        .map((order, oi) => order.map((o) => (o.resolved ? o : { ...o, subGroup: [oi].concat(...(o.subGroup ?? [])) })))
+        .flat();
+    let lastSubGroup;
+    let subGroupCount = 0;
     let groupPosition = 1;
     let priorPositionResolution;
     groupOrder.forEach((finishingPosition, index) => {
@@ -20662,13 +20685,20 @@ function getGroupOrder(params) {
             groupPosition += 1;
         }
         priorPositionResolution = finishingPosition.resolved;
+        const subGroup = parseInt(finishingPosition.subGroup?.join('') || 0);
         if (finishingPosition.resolved) {
             finishingPosition.position = index + 1;
             groupPosition = finishingPosition.position;
         }
         else {
+            if (lastSubGroup && subGroup > lastSubGroup) {
+                groupPosition += subGroupCount;
+                subGroupCount = 0;
+            }
             finishingPosition.position = groupPosition;
+            subGroupCount += 1;
         }
+        lastSubGroup = subGroup;
     });
     const positions = groupOrder.map(({ position }) => position);
     const positionsCount = instanceCount(positions);
@@ -20717,11 +20747,11 @@ function processAttribute({ disableHeadToHead, participantIds, matchUpFormat, ta
     const report = [{ attribute, reversed, groups, idsFilter }];
     let order;
     if (Object.keys(groups).length > 1 && participantIds.length) {
-        order = Object.keys(groups)
+        const sortedTallyGroups = Object.keys(groups)
             .map((key) => parseFloat(key))
             .sort((a, b) => (reversed ? a - b : b - a))
-            .map((key) => groups[key])
-            .map((participantIds) => {
+            .map((key) => groups[key]);
+        const sortedOrder = sortedTallyGroups.map((participantIds) => {
             const result = groupSubSort({
                 participantResults,
                 disableHeadToHead,
@@ -20732,8 +20762,10 @@ function processAttribute({ disableHeadToHead, participantIds, matchUpFormat, ta
             });
             report.push(...(result.report ?? []));
             return result.order;
-        })
-            .flat(Infinity);
+        });
+        order = sortedOrder
+            .map((order, oi) => order.map((o) => (o.resolved ? o : { ...o, subGroup: [oi].concat(...(o.subGroup ?? [])) })))
+            .flat();
     }
     return { order, report };
 }
@@ -20749,11 +20781,11 @@ function groupSubSort({ participantResults, disableHeadToHead, participantIds, m
     }
     if (participantIds?.length === 2 &&
         (!tallyPolicy?.headToHead || (!tallyPolicy.headToHead.disabled && !disableHeadToHead))) {
-        const result = headToHeadWinner({ participantIds, participantResults });
+        const result = getHeadToHeadWinner({ participantIds, participantResults });
         if (result) {
             const headToHeadWinner = result[0].participantId;
             report.push({ attribute: 'head2Head', participantIds, headToHeadWinner });
-            return { order: [result], headToHeadWinner, report };
+            return { order: result, headToHeadWinner, report };
         }
     }
     const directives = tallyPolicy?.tallyDirectives || headToHeadTallyDirectives;
@@ -20786,7 +20818,7 @@ function groupSubSort({ participantResults, disableHeadToHead, participantIds, m
         report,
     };
 }
-function headToHeadWinner({ participantIds, participantResults }) {
+function getHeadToHeadWinner({ participantIds, participantResults }) {
     if (!participantIds)
         return;
     if (participantResults[participantIds[0]].victories.includes(participantIds[1])) {
@@ -20998,16 +21030,13 @@ function getMatchUp$1({ matchUps, matchUpId }) {
     return { matchUp };
 }
 
-function findDrawMatchUp({ tournamentParticipants, afterRecoveryTimes, contextContent, contextProfile, drawDefinition, matchUpsMap, matchUpId, inContext, context, event, }) {
-    if (!drawDefinition)
-        return { error: MISSING_DRAW_DEFINITION };
-    if (!matchUpId)
-        return { error: MISSING_MATCHUP_ID };
-    if (typeof matchUpId !== 'string')
-        return { error: INVALID_VALUES };
+function findDrawMatchUp(params) {
+    const paramsCheck = checkRequiredParameters(params, [{ [DRAW_DEFINITION]: true, [MATCHUP_ID]: true }]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const { tournamentParticipants, afterRecoveryTimes, contextProfile, drawDefinition, matchUpsMap, matchUpId, inContext, context, event, } = params;
     const { structures = [] } = getDrawStructures({ drawDefinition });
-    if (contextProfile && !contextContent)
-        contextContent = getContextContent({ contextProfile, drawDefinition });
+    const contextContent = params.contextContent || (contextProfile && getContextContent({ contextProfile, drawDefinition }));
     for (const structure of structures) {
         const { matchUps } = getAllStructureMatchUps({
             tournamentParticipants,
@@ -21865,30 +21894,9 @@ function validateTieFormat(params) {
     const event = params?.event;
     const stack = 'validateTieFormat';
     const errors = [];
-    if (!params || !tieFormat || typeof tieFormat !== 'object') {
-        errors.push('tieFormat must be an object');
-        return decorateResult({
-            result: { error: INVALID_TIE_FORMAT },
-            context: { tieFormat, errors },
-            stack,
-        });
-    }
-    if (typeof tieFormat.winCriteria !== 'object') {
-        errors.push('tieFormat.winCriteria must be an object');
-        return decorateResult({
-            result: { error: INVALID_TIE_FORMAT },
-            context: { tieFormat, errors },
-            stack,
-        });
-    }
-    if (!Array.isArray(tieFormat.collectionDefinitions)) {
-        errors.push(mustBeAnArray('tieFormat.collectionDefinitions'));
-        return decorateResult({
-            result: { error: INVALID_TIE_FORMAT },
-            context: { tieFormat, errors },
-            stack,
-        });
-    }
+    const paramsCheck = checkParams$1({ ...params, stack });
+    if (paramsCheck?.error)
+        return paramsCheck;
     let aggregateValueImperative;
     const validCollections = tieFormat.collectionDefinitions.every((collectionDefinition) => {
         const { setValue, scoreValue, collectionValue } = collectionDefinition;
@@ -21941,6 +21949,31 @@ function validateTieFormat(params) {
     }
     return result;
 }
+function checkParams$1(params) {
+    const { tieFormat, stack } = params;
+    if (!params || !tieFormat || !isObject(tieFormat)) {
+        return decorateResult({
+            result: { error: INVALID_TIE_FORMAT },
+            context: { tieFormat, message: 'tieformat must be an object' },
+            stack,
+        });
+    }
+    if (!isObject(tieFormat.winCriteria)) {
+        return decorateResult({
+            result: { error: INVALID_TIE_FORMAT },
+            context: { tieFormat, message: 'tieformat.winCritiera must be an object' },
+            stack,
+        });
+    }
+    if (!Array.isArray(tieFormat.collectionDefinitions)) {
+        return decorateResult({
+            result: { error: INVALID_TIE_FORMAT },
+            context: { tieFormat, message: 'collectionDefinitions must be an array' },
+            stack,
+        });
+    }
+    return { ...SUCCESS };
+}
 
 function generateTieMatchUpScore(params) {
     const { sideAdjustments = [0, 0], separator = '-', drawDefinition, matchUpsMap, structure, matchUp, event, } = params;
@@ -30547,13 +30580,13 @@ function validateScore({ existingMatchUpStatus, matchUpFormat, matchUpStatus, wi
                 [side1TiebreakScore, side2TiebreakScore],
                 [side1PointScore, side2PointScore],
             ]
-                .filter((pair) => pair.some((value) => value !== undefined))
+                .filter((pair) => pair.some((value) => ![undefined, null].includes(value)))
                 .every((pair) => pair.every((numericValue) => isConvertableInteger(numericValue)));
             if (!numericValuePairs) {
                 return { error: INVALID_VALUES, info: 'non-numeric values' };
             }
             const numericValues = [setNumber, winningSide]
-                .filter((value) => value !== undefined)
+                .filter((value) => ![undefined, null].includes(value))
                 .every((numericValue) => isConvertableInteger(numericValue));
             if (!numericValues) {
                 return { error: INVALID_VALUES, info: 'non-numeric values' };
@@ -33644,6 +33677,7 @@ function getTournamentInfo(params) {
                 eventInfo.push(info);
         }
     }
+    tournamentInfo.publishState = publishState?.tournament;
     tournamentInfo.eventInfo = eventInfo;
     return {
         tournamentInfo: makeDeepCopy(tournamentInfo, false, true),
@@ -34598,6 +34632,7 @@ var query$5 = {
     getEventData: getEventData,
     getEventPublishStatus: getEventPublishStatus,
     getPublishState: getPublishState,
+    getTournamentPublishStatus: getTournamentPublishStatus,
     getVenueData: getVenueData
 };
 
@@ -35981,11 +36016,9 @@ function competitionScheduleMatchUps(params) {
     const getResult = getSchedulingProfile(params);
     const schedulingProfile = getResult.schedulingProfile;
     const { sortDateMatchUps = true, courtCompletedMatchUps, alwaysReturnCompleted, activeTournamentId, tournamentRecords, withCourtGridRows, minCourtGridRows, usePublishState, status = PUBLIC, sortCourtsData, } = params;
+    const tournamentId = activeTournamentId ?? getTournamentId() ?? Object.keys(tournamentRecords)[0];
     const tournamentPublishStatus = usePublishState
-        ? getTournamentTimeItem({
-            tournamentRecord: tournamentRecords[activeTournamentId ?? getTournamentId() ?? Object.keys(tournamentRecords)[0]],
-            itemType: `${PUBLISH}.${STATUS$1}`,
-        }).timeItem?.itemValue?.[status]
+        ? getTournamentPublishStatus({ tournamentRecord: tournamentRecords[tournamentId], status })
         : undefined;
     const allCompletedMatchUps = alwaysReturnCompleted
         ? getCompetitionMatchUps({
@@ -35997,7 +36030,7 @@ function competitionScheduleMatchUps(params) {
             contextFilters: params.contextFilters,
         }).completedMatchUps
         : [];
-    if (usePublishState && (!tournamentPublishStatus || !Object.keys(tournamentPublishStatus).length)) {
+    if (usePublishState && !tournamentPublishStatus?.orderOfPlay?.published) {
         return {
             completedMatchUps: allCompletedMatchUps,
             dateMatchUps: [],
@@ -37335,6 +37368,7 @@ var index$f = {
     getTournamentInfo: getTournamentInfo,
     getTournamentPenalties: getTournamentPenalties,
     getTournamentPersons: getTournamentPersons,
+    getTournamentPublishStatus: getTournamentPublishStatus,
     getTournamentStructures: getTournamentStructures,
     getTournamentTimeItem: getTournamentTimeItem,
     getValidGroupSizes: getValidGroupSizes,
@@ -39532,8 +39566,86 @@ function modifyEvent(params) {
     ]);
     if (paramsCheck.error)
         return paramsCheck;
-    const { tournamentRecord, eventUpdates, event } = params;
+    const { eventUpdates, event } = params;
     const stack = 'modifyEvent';
+    const enteredParticipants = getEnteredParticipants(params);
+    const participantsProfile = getParticipantsProfile({ enteredParticipants });
+    const { enteredParticipantGenders, enteredParticipantTypes } = participantsProfile;
+    const genderResult = checkGenderUpdates({ enteredParticipantGenders, eventUpdates, stack });
+    if (genderResult.error)
+        return genderResult;
+    const eventTypeResult = checkEventType({ enteredParticipantTypes, eventUpdates, stack });
+    if (eventTypeResult.error)
+        return eventTypeResult;
+    const categoryResult = checkCategoryUpdates({ ...params, ...participantsProfile, enteredParticipants, stack });
+    if (categoryResult.error)
+        return categoryResult;
+    const dateResult = dateUpdates({ ...params, stack });
+    if (dateResult.error)
+        return dateResult;
+    if (eventUpdates.eventType)
+        event.eventType = eventUpdates.eventType;
+    if (eventUpdates.eventName)
+        event.eventName = eventUpdates.eventName;
+    if (eventUpdates.gender)
+        event.gender = eventUpdates.gender;
+    return { ...SUCCESS };
+}
+function checkCategoryUpdates(params) {
+    const category = params.eventUpdates?.category;
+    if (!category)
+        return { ...SUCCESS };
+    const categoryCheck = validateCategory({ category });
+    if (categoryCheck.error)
+        return categoryCheck;
+    if (params.event.eventType === TEAM$2) {
+        const drawTieFormats = params.event?.drawDefinitions?.map((draw) => getObjectTieFormat(draw)) ?? [];
+        const eventTieFormat = getObjectTieFormat(params.event);
+        const eventMatchUps = allEventMatchUps(params)?.matchUps ?? [];
+        const matchUpTieFormats = eventMatchUps.map((matchUp) => getObjectTieFormat(matchUp)) ?? [];
+        const tieFormats = [eventTieFormat, ...drawTieFormats, ...matchUpTieFormats].filter(Boolean);
+        const validCategory = tieFormats.every((tieFormat) => tieFormat.collectionDefinitions.every((cd) => !cd.category || categoryCanContain({ category: params.eventUpdates.category, childCategory: cd.category })));
+        if (!validCategory)
+            return decorateResult({ result: { error: INVALID_CATEGORY }, stack: params.stack });
+    }
+    if (params.enteredParticipants?.length) {
+        const startDate = params.eventUpdates.startDate || params.event.startDate || params.tournamentRecord.startDate;
+        const endDate = params.eventUpdates.endDate || params.event.endDate || params.tournamentRecord.endDate;
+        const individualParticpants = params.enteredParticipants
+            .map((p) => (p.participantType === INDIVIDUAL ? p : p.individualParticpants ?? []))
+            .flat();
+        const startAgeDetails = getCategoryAgeDetails({ category, consideredDate: startDate });
+        const endAgeDetails = getCategoryAgeDetails({ category, consideredDate: endDate });
+        if (startAgeDetails?.ageMinDate ||
+            startAgeDetails?.ageMaxDate ||
+            endAgeDetails?.ageMinDate ||
+            endAgeDetails?.ageMaxDate) {
+            for (const individualParticipant of individualParticpants) {
+                const birthDate = individualParticipant.person?.birthDate;
+                if (!birthDate)
+                    return decorateResult({ result: { error: MISSING_BIRTH_DATE }, stack: params.stack });
+                const birthTime = new Date(birthDate).getTime();
+                if (startAgeDetails.ageMinDate || startAgeDetails.ageMaxDate) {
+                    const minTime = new Date(startAgeDetails.ageMinDate).getTime();
+                    const maxTime = new Date(startAgeDetails.ageMaxDate).getTime();
+                    if (birthTime < minTime || birthTime > maxTime) {
+                        return decorateResult({ result: { error: CATEGORY_MISMATCH }, stack: params.stack });
+                    }
+                }
+                if (endAgeDetails.ageMin || endAgeDetails.ageMax) {
+                    const minTime = new Date(endAgeDetails.ageMinDate).getTime();
+                    const maxTime = new Date(endAgeDetails.ageMaxDate).getTime();
+                    if (birthTime < minTime || birthTime > maxTime) {
+                        return decorateResult({ result: { error: CATEGORY_MISMATCH }, stack: params.stack });
+                    }
+                }
+            }
+        }
+    }
+    return { ...SUCCESS };
+}
+function dateUpdates(params) {
+    const { tournamentRecord, eventUpdates, event, stack } = params;
     if (eventUpdates.startDate || eventUpdates.endDate) {
         const result = setEventDates({
             startDate: eventUpdates.startDate,
@@ -39544,19 +39656,25 @@ function modifyEvent(params) {
         if (result.error)
             return decorateResult({ result, stack });
     }
+    return { ...SUCCESS };
+}
+function getEnteredParticipants(params) {
+    const { tournamentRecord, event } = params;
     const enteredParticipantIds = event?.entries
         ?.filter(({ entryStatus }) => {
         const status = entryStatus;
         return [...STRUCTURE_SELECTED_STATUSES, ALTERNATE].includes(status);
     })
         .map(({ participantId }) => participantId) ?? [];
-    const enteredParticipants = enteredParticipantIds
+    return enteredParticipantIds
         ? getParticipants({
             participantFilters: { participantIds: enteredParticipantIds },
             withIndividualParticipants: true,
             tournamentRecord,
         }).participants ?? []
         : [];
+}
+function getParticipantsProfile({ enteredParticipants }) {
     const genderAccumulator = [];
     const enteredParticipantTypes = enteredParticipants.reduce((types, participant) => {
         const genders = participant.person?.sex
@@ -39566,32 +39684,32 @@ function modifyEvent(params) {
         return !types.includes(participant.participantType) ? types.concat(participant.participantType) : types;
     }, []);
     const enteredParticipantGenders = unique(genderAccumulator);
+    return { enteredParticipantTypes, enteredParticipantGenders };
+}
+function checkGenderUpdates({ enteredParticipantGenders, eventUpdates, stack }) {
     const validGender = !enteredParticipantGenders.length ||
         [MIXED, ANY].includes(eventUpdates.gender ?? '') ||
         (enteredParticipantGenders.length === 1 && enteredParticipantGenders[0] === eventUpdates.gender);
-    if (eventUpdates.gender && !validGender)
-        return decorateResult({
+    return eventUpdates.gender && !validGender
+        ? decorateResult({
             context: { gender: eventUpdates.gender, validGender },
-            result: { error: INVALID_VALUES },
+            result: { error: INVALID_GENDER },
             stack,
-        });
+        })
+        : { ...SUCCESS };
+}
+function checkEventType({ enteredParticipantTypes, eventUpdates, stack }) {
     const validEventTypes = (enteredParticipantTypes.includes(TEAM$2) && [TEAM$2]) ||
         (enteredParticipantTypes.includes(INDIVIDUAL) && [SINGLES$1]) ||
         (enteredParticipantTypes.includes(PAIR) && [DOUBLES$1]) || [DOUBLES$1, SINGLES$1, TEAM$2];
     const validEventType = validEventTypes.includes(eventUpdates.eventType ?? '');
-    if (eventUpdates.eventType && !validEventType)
-        return decorateResult({
+    return eventUpdates.eventType && !validEventType
+        ? decorateResult({
             context: { participantType: eventUpdates.eventType, validEventType },
-            result: { error: INVALID_VALUES },
+            result: { error: INVALID_EVENT_TYPE },
             stack,
-        });
-    if (eventUpdates.eventType)
-        event.eventType = eventUpdates.eventType;
-    if (eventUpdates.eventName)
-        event.eventName = eventUpdates.eventName;
-    if (eventUpdates.gender)
-        event.gender = eventUpdates.gender;
-    return { ...SUCCESS };
+        })
+        : { ...SUCCESS };
 }
 
 function addFlight({ qualifyingPositions, drawEntries = [], drawName, drawId, event, stage, }) {
@@ -46682,7 +46800,7 @@ function v2Scheduler({ schedulingProfileModifications, checkPotentialRequestConf
 }
 
 function clearScheduledMatchUps(params) {
-    const { scheduleAttributes = ['scheduledDate', 'scheduledTime'], ignoreMatchUpStatuses = completedMatchUpStatuses, scheduledDates, venueIds, } = params;
+    const { scheduleAttributes = ['scheduledDate', 'scheduledTime', 'courtOrder'], ignoreMatchUpStatuses = completedMatchUpStatuses, scheduledDates, venueIds, } = params;
     const tournamentRecords = resolveTournamentRecords(params);
     const tournamentIds = isObject(tournamentRecords)
         ? Object.values(tournamentRecords)
@@ -46707,7 +46825,7 @@ function clearScheduledMatchUps(params) {
     }
     return { ...SUCCESS, clearedScheduleCount };
 }
-function clearSchedules({ scheduleAttributes = ['scheduledDate', 'scheduledTime'], ignoreMatchUpStatuses = completedMatchUpStatuses, tournamentRecord, scheduledDates, venueIds = [], }) {
+function clearSchedules({ scheduleAttributes = ['scheduledDate', 'scheduledTime', 'courtOrder'], ignoreMatchUpStatuses = completedMatchUpStatuses, tournamentRecord, scheduledDates, venueIds = [], }) {
     if (typeof tournamentRecord !== 'object')
         return { error: MISSING_TOURNAMENT_RECORD };
     if (!Array.isArray(ignoreMatchUpStatuses) || !Array.isArray(venueIds)) {
@@ -46738,7 +46856,7 @@ function clearSchedules({ scheduleAttributes = ['scheduledDate', 'scheduledTime'
             let modified = false;
             matchUp.timeItems = (matchUp.timeItems ?? []).filter((timeItem) => {
                 const preserve = timeItem?.itemType &&
-                    ![ALLOCATE_COURTS, ASSIGN_COURT, ASSIGN_VENUE, SCHEDULED_DATE, SCHEDULED_TIME].includes(timeItem?.itemType);
+                    ![ALLOCATE_COURTS, ASSIGN_COURT, ASSIGN_VENUE, COURT_ORDER, SCHEDULED_DATE, SCHEDULED_TIME].includes(timeItem?.itemType);
                 if (!preserve)
                     modified = true;
                 return preserve;
@@ -51786,39 +51904,58 @@ function unPublishEventSeeding({ removePriorValues = true, seedingScaleNames, to
     return { ...SUCCESS };
 }
 
-function unPublishOrderOfPlay(params) {
-    const tournamentRecords = params?.tournamentRecords ??
-        (params?.tournamentRecord && {
-            [params.tournamentRecord.tournamentId]: params.tournamentRecord,
-        }) ??
-        {};
+function unPublishParticipants(params) {
+    const tournamentRecords = resolveTournamentRecords(params);
     if (!Object.keys(tournamentRecords).length)
         return { error: MISSING_TOURNAMENT_RECORDS };
     for (const tournamentRecord of Object.values(tournamentRecords)) {
-        const result = unPublishOOP({
-            tournamentRecord,
-            ...params,
-        });
+        const result = unpublish({ tournamentRecord, ...params });
         if (result.error)
             return result;
     }
     return { ...SUCCESS };
 }
-function unPublishOOP({ removePriorValues = true, tournamentRecord, status = PUBLIC }) {
+function unpublish({ removePriorValues = true, tournamentRecord, status = PUBLIC }) {
     if (!tournamentRecord)
         return { error: MISSING_TOURNAMENT_RECORD };
     const itemType = `${PUBLISH}.${STATUS$1}`;
-    const { timeItem } = getTimeItem({
+    const { timeItem } = getTimeItem({ element: tournamentRecord, itemType });
+    const itemValue = timeItem?.itemValue || { [status]: {} };
+    if (itemValue[status])
+        delete itemValue[status].participants;
+    const updatedTimeItem = { itemValue, itemType };
+    addTimeItem({
+        timeItem: updatedTimeItem,
         element: tournamentRecord,
-        itemType,
+        removePriorValues,
     });
+    addNotice({
+        payload: { tournamentId: tournamentRecord.tournamentId },
+        topic: UNPUBLISH_PARTICIPANTS,
+    });
+    return { ...SUCCESS };
+}
+
+function unPublishOrderOfPlay(params) {
+    const tournamentRecords = resolveTournamentRecords(params);
+    if (!Object.keys(tournamentRecords).length)
+        return { error: MISSING_TOURNAMENT_RECORDS };
+    for (const tournamentRecord of Object.values(tournamentRecords)) {
+        const result = unPublishOOP({ tournamentRecord, ...params });
+        if (result.error)
+            return result;
+    }
+    return { ...SUCCESS };
+}
+function unPublishOOP({ removePriorValues = true, tournamentRecord, status = PUBLIC }) {
+    if (!tournamentRecord)
+        return { error: MISSING_TOURNAMENT_RECORD };
+    const itemType = `${PUBLISH}.${STATUS$1}`;
+    const { timeItem } = getTimeItem({ element: tournamentRecord, itemType });
     const itemValue = timeItem?.itemValue || { [status]: {} };
     if (itemValue[status])
         delete itemValue[status].orderOfPlay;
-    const updatedTimeItem = {
-        itemValue,
-        itemType,
-    };
+    const updatedTimeItem = { itemValue, itemType };
     addTimeItem({
         timeItem: updatedTimeItem,
         element: tournamentRecord,
@@ -51833,34 +51970,56 @@ function unPublishOOP({ removePriorValues = true, tournamentRecord, status = PUB
     return { ...SUCCESS };
 }
 
-function publishOrderOfPlay(params) {
+function publishParticipants(params) {
     const tournamentRecords = resolveTournamentRecords(params);
     if (!Object.keys(tournamentRecords).length)
         return { error: MISSING_TOURNAMENT_RECORDS };
     for (const tournamentRecord of Object.values(tournamentRecords)) {
-        const result = publishOOP({
-            tournamentRecord,
-            ...params,
-        });
+        const result = publish({ tournamentRecord, ...params });
         if (result.error)
             return result;
     }
     return { ...SUCCESS };
 }
-function publishOOP({ scheduledDates = [], removePriorValues, tournamentRecord, status = PUBLIC, eventIds = [] }) {
+function publish({ removePriorValues, tournamentRecord, status = PUBLIC }) {
     if (!tournamentRecord)
         return { error: MISSING_TOURNAMENT_RECORD };
     const itemType = `${PUBLISH}.${STATUS$1}`;
-    const { timeItem } = getTimeItem({
+    const { timeItem } = getTimeItem({ element: tournamentRecord, itemType });
+    const itemValue = timeItem?.itemValue || { [status]: {} };
+    itemValue[status].participants = { published: true };
+    const updatedTimeItem = { itemValue, itemType };
+    addTimeItem({
+        timeItem: updatedTimeItem,
         element: tournamentRecord,
-        itemType,
+        removePriorValues,
     });
+    addNotice({
+        payload: { tournamentId: tournamentRecord.tournamentId },
+        topic: PUBLISH_PARTICIPANTS,
+    });
+    return { ...SUCCESS };
+}
+
+function publishOrderOfPlay(params) {
+    const tournamentRecords = resolveTournamentRecords(params);
+    if (!Object.keys(tournamentRecords).length)
+        return { error: MISSING_TOURNAMENT_RECORDS };
+    for (const tournamentRecord of Object.values(tournamentRecords)) {
+        const result = publishOOP({ tournamentRecord, ...params });
+        if (result.error)
+            return result;
+    }
+    return { ...SUCCESS };
+}
+function publishOOP({ scheduledDates = [], removePriorValues, tournamentRecord, status = PUBLIC, eventIds = [] }) {
+    if (!tournamentRecord)
+        return { error: MISSING_TOURNAMENT_RECORD };
+    const itemType = `${PUBLISH}.${STATUS$1}`;
+    const { timeItem } = getTimeItem({ element: tournamentRecord, itemType });
     const itemValue = timeItem?.itemValue || { [status]: {} };
     itemValue[status].orderOfPlay = { published: true, scheduledDates, eventIds };
-    const updatedTimeItem = {
-        itemValue,
-        itemType,
-    };
+    const updatedTimeItem = { itemValue, itemType };
     addTimeItem({
         timeItem: updatedTimeItem,
         element: tournamentRecord,
@@ -51918,10 +52077,12 @@ var mutate$4 = {
     publishEvent: publishEvent,
     publishEventSeeding: publishEventSeeding,
     publishOrderOfPlay: publishOrderOfPlay,
+    publishParticipants: publishParticipants,
     setEventDisplay: setEventDisplay,
     unPublishEvent: unPublishEvent,
     unPublishEventSeeding: unPublishEventSeeding,
-    unPublishOrderOfPlay: unPublishOrderOfPlay
+    unPublishOrderOfPlay: unPublishOrderOfPlay,
+    unPublishParticipants: unPublishParticipants
 };
 
 var index$7 = {
@@ -51933,16 +52094,19 @@ var index$7 = {
     getEventData: getEventData,
     getEventPublishStatus: getEventPublishStatus,
     getPublishState: getPublishState,
+    getTournamentPublishStatus: getTournamentPublishStatus,
     getVenueData: getVenueData,
     mutate: mutate$4,
     publishEvent: publishEvent,
     publishEventSeeding: publishEventSeeding,
     publishOrderOfPlay: publishOrderOfPlay,
+    publishParticipants: publishParticipants,
     query: query$5,
     setEventDisplay: setEventDisplay,
     unPublishEvent: unPublishEvent,
     unPublishEventSeeding: unPublishEventSeeding,
-    unPublishOrderOfPlay: unPublishOrderOfPlay
+    unPublishOrderOfPlay: unPublishOrderOfPlay,
+    unPublishParticipants: unPublishParticipants
 };
 
 function getParticipantStats({ withCompetitiveProfiles, opponentParticipantId, withIndividualStats, teamParticipantId, tournamentRecord, withScaleValues, tallyPolicy, matchUps, }) {