tods-competition-factory 1.8.46 → 1.9.0

package/dist/forge/query.mjs

@@ -743,7 +743,7 @@ function getAccessorValue({ element, accessor }) {
 }
 
 function isObject(obj) {
-  return typeof obj === "object";
+  return obj !== null && typeof obj === "object";
 }
 const extractAttributes = (accessor) => (element) => !accessor || typeof element !== "object" ? void 0 : Array.isArray(accessor) && accessor.map((a) => ({
   [a]: getAccessorValue({ element, accessor: a })?.value
@@ -1694,6 +1694,99 @@ function getScheduleTiming({
   return { scheduleTiming };
 }
 
+function getTimeItem({
+  returnPreviousValues,
+  itemSubTypes,
+  itemType,
+  element
+}) {
+  if (!element)
+    return { error: MISSING_VALUE, info: ELEMENT_REQUIRED };
+  if (itemSubTypes && !Array.isArray(itemSubTypes))
+    return { error: INVALID_VALUES, context: { itemSubTypes } };
+  if (!Array.isArray(element.timeItems))
+    return { error: MISSING_TIME_ITEMS };
+  const filteredSorted = element.timeItems.filter((timeItem2) => timeItem2?.itemType === itemType).filter(
+    (timeItem2) => !itemSubTypes?.length || itemSubTypes.some(
+      (subType) => timeItem2?.itemSubTypes?.includes(subType)
+    )
+  ).sort((a, b) => {
+    const aDate = new Date(a.createdAt || void 0).getTime();
+    const bDate = new Date(b.createdAt || void 0).getTime();
+    return aDate - bDate;
+  });
+  const timeItem = filteredSorted.pop();
+  if (timeItem) {
+    const result = { timeItem, ...SUCCESS };
+    if (returnPreviousValues)
+      Object.assign(result, { previousItems: filteredSorted });
+    return result;
+  } else {
+    return { info: NOT_FOUND };
+  }
+}
+function getEventTimeItem({
+  returnPreviousValues,
+  itemSubTypes,
+  itemType,
+  event
+}) {
+  if (!event)
+    return { error: MISSING_EVENT };
+  if (!event.timeItems)
+    return { info: NOT_FOUND };
+  const { timeItem, previousItems, info } = getTimeItem({
+    returnPreviousValues,
+    element: event,
+    itemSubTypes,
+    itemType
+  });
+  return timeItem && { timeItem, previousItems } || { info };
+}
+function getTournamentTimeItem({
+  returnPreviousValues,
+  tournamentRecord,
+  itemSubTypes,
+  itemType
+}) {
+  if (!tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  if (!tournamentRecord.timeItems)
+    return { info: NOT_FOUND };
+  const { timeItem, previousItems, info } = getTimeItem({
+    element: tournamentRecord,
+    returnPreviousValues,
+    itemSubTypes,
+    itemType
+  });
+  return timeItem && { timeItem, previousItems } || { info };
+}
+
+const CHECK_IN = "CHECK_IN";
+const CHECK_OUT = "CHECK_OUT";
+const ASSIGN_VENUE = "SCHEDULE.ASSIGNMENT.VENUE";
+const ALLOCATE_COURTS = "SCHEDULE.ALLOCATION.COURTS";
+const ASSIGN_COURT = "SCHEDULE.ASSIGNMENT.COURT";
+const COURT_ORDER = "SCHEDULE.COURT.ORDER";
+const SCHEDULED_DATE = "SCHEDULE.DATE";
+const SCHEDULED_TIME = "SCHEDULE.TIME.SCHEDULED";
+const START_TIME = "SCHEDULE.TIME.START";
+const STOP_TIME = "SCHEDULE.TIME.STOP";
+const RESUME_TIME = "SCHEDULE.TIME.RESUME";
+const END_TIME = "SCHEDULE.TIME.END";
+const TIME_MODIFIERS = "SCHEDULE.TIME.MODIFIERS";
+const PUBLISH = "PUBLISH";
+const PUBLIC = "PUBLIC";
+const STATUS$1 = "STATUS";
+
+function getEventPublishStatus({ event, status = PUBLIC }) {
+  const itemType = `${PUBLISH}.${STATUS$1}`;
+  return getEventTimeItem({
+    itemType,
+    event
+  })?.timeItem?.itemValue?.[status];
+}
+
 const SIGN_IN_STATUS = "SIGN_IN_STATUS";
 const INDIVIDUAL = ParticipantTypeEnum.Individual;
 const GROUP = ParticipantTypeEnum.Group;
@@ -3560,74 +3653,6 @@ function addIndividualParticipants({ participantMap, template }) {
   }
 }
 
-function getTimeItem({
-  returnPreviousValues,
-  itemSubTypes,
-  itemType,
-  element
-}) {
-  if (!element)
-    return { error: MISSING_VALUE, info: ELEMENT_REQUIRED };
-  if (itemSubTypes && !Array.isArray(itemSubTypes))
-    return { error: INVALID_VALUES, context: { itemSubTypes } };
-  if (!Array.isArray(element.timeItems))
-    return { error: MISSING_TIME_ITEMS };
-  const filteredSorted = element.timeItems.filter((timeItem2) => timeItem2?.itemType === itemType).filter(
-    (timeItem2) => !itemSubTypes?.length || itemSubTypes.some(
-      (subType) => timeItem2?.itemSubTypes?.includes(subType)
-    )
-  ).sort((a, b) => {
-    const aDate = new Date(a.createdAt || void 0).getTime();
-    const bDate = new Date(b.createdAt || void 0).getTime();
-    return aDate - bDate;
-  });
-  const timeItem = filteredSorted.pop();
-  if (timeItem) {
-    const result = { timeItem, ...SUCCESS };
-    if (returnPreviousValues)
-      Object.assign(result, { previousItems: filteredSorted });
-    return result;
-  } else {
-    return { info: NOT_FOUND };
-  }
-}
-function getEventTimeItem({
-  returnPreviousValues,
-  itemSubTypes,
-  itemType,
-  event
-}) {
-  if (!event)
-    return { error: MISSING_EVENT };
-  if (!event.timeItems)
-    return { info: NOT_FOUND };
-  const { timeItem, previousItems, info } = getTimeItem({
-    returnPreviousValues,
-    element: event,
-    itemSubTypes,
-    itemType
-  });
-  return timeItem && { timeItem, previousItems } || { info };
-}
-function getTournamentTimeItem({
-  returnPreviousValues,
-  tournamentRecord,
-  itemSubTypes,
-  itemType
-}) {
-  if (!tournamentRecord)
-    return { error: MISSING_TOURNAMENT_RECORD };
-  if (!tournamentRecord.timeItems)
-    return { info: NOT_FOUND };
-  const { timeItem, previousItems, info } = getTimeItem({
-    element: tournamentRecord,
-    returnPreviousValues,
-    itemSubTypes,
-    itemType
-  });
-  return timeItem && { timeItem, previousItems } || { info };
-}
-
 const SINGLES_MATCHUP = "SINGLES";
 const SINGLES$1 = "SINGLES";
 const DOUBLES_MATCHUP = "DOUBLES";
@@ -5528,23 +5553,6 @@ function getVenueData({ tournamentRecord, venueId }) {
   return { ...SUCCESS, venueData: makeDeepCopy(venueData, false, true) };
 }
 
-const CHECK_IN = "CHECK_IN";
-const CHECK_OUT = "CHECK_OUT";
-const ASSIGN_VENUE = "SCHEDULE.ASSIGNMENT.VENUE";
-const ALLOCATE_COURTS = "SCHEDULE.ALLOCATION.COURTS";
-const ASSIGN_COURT = "SCHEDULE.ASSIGNMENT.COURT";
-const COURT_ORDER = "SCHEDULE.COURT.ORDER";
-const SCHEDULED_DATE = "SCHEDULE.DATE";
-const SCHEDULED_TIME = "SCHEDULE.TIME.SCHEDULED";
-const START_TIME = "SCHEDULE.TIME.START";
-const STOP_TIME = "SCHEDULE.TIME.STOP";
-const RESUME_TIME = "SCHEDULE.TIME.RESUME";
-const END_TIME = "SCHEDULE.TIME.END";
-const TIME_MODIFIERS = "SCHEDULE.TIME.MODIFIERS";
-const PUBLISH = "PUBLISH";
-const PUBLIC = "PUBLIC";
-const STATUS$1 = "STATUS";
-
 function getTimeStamp(item) {
   return !item.createdAt ? 0 : new Date(item.createdAt).getTime();
 }
@@ -5762,8 +5770,10 @@ function getMatchUpScheduleDetails({
   scheduleVisibilityFilters,
   afterRecoveryTimes,
   tournamentRecord,
+  usePublishState,
   scheduleTiming,
   matchUpFormat,
+  publishStatus,
   matchUpType,
   matchUp,
   event
@@ -5880,15 +5890,36 @@ function getMatchUpScheduleDetails({
     });
   } else {
     schedule = definedAttributes({
-      time,
+      milliseconds,
       startTime,
       endTime,
-      milliseconds
+      time
     });
   }
-  const hasCompletedStatus = matchUp.matchUpStatus && completedMatchUpStatuses.includes(matchUp.matchUpStatus);
   const { scheduledDate } = scheduledMatchUpDate({ matchUp });
   const { scheduledTime } = scheduledMatchUpTime({ matchUp });
+  if (usePublishState && publishStatus?.displaySettings?.draws) {
+    const drawSettings = publishStatus.displaySettings.draws;
+    const scheduleDetails = (drawSettings?.[matchUp.drawId] ?? drawSettings?.default)?.scheduleDetails;
+    if (scheduleDetails) {
+      const scheduleAttributes = (scheduleDetails.find(
+        (details) => scheduledDate && details.dates?.includes(scheduledDate)
+      ) ?? scheduleDetails.find((details) => !details.dates?.length))?.attributes;
+      if (scheduleAttributes) {
+        const template = Object.assign(
+          {},
+          ...Object.keys(schedule).map((key) => ({ [key]: true })),
+          // overwrite with publishStatus attributes
+          scheduleAttributes
+        );
+        schedule = attributeFilter({
+          source: schedule,
+          template
+        });
+      }
+    }
+  }
+  const hasCompletedStatus = matchUp.matchUpStatus && completedMatchUpStatuses.includes(matchUp.matchUpStatus);
   const endDate = hasCompletedStatus && (extractDate(endTime) || extractDate(scheduledDate) || extractDate(scheduledTime)) || void 0;
   return { schedule, endDate };
 }
@@ -6970,6 +7001,7 @@ function getAllStructureMatchUps({
   policyDefinitions,
   tournamentRecord,
   seedAssignments,
+  usePublishState,
   contextFilters,
   contextContent,
   matchUpFilters,
@@ -6977,6 +7009,7 @@ function getAllStructureMatchUps({
   scheduleTiming,
   contextProfile,
   drawDefinition,
+  publishStatus,
   context = {},
   exitProfiles,
   matchUpsMap,
@@ -7085,6 +7118,8 @@ function getAllStructureMatchUps({
         roundNamingProfile,
         initialRoundOfPlay,
         appliedPolicies,
+        usePublishState,
+        publishStatus,
         isRoundRobin,
         roundProfile,
         matchUp,
@@ -7154,6 +7189,8 @@ function getAllStructureMatchUps({
     tieDrawPositions,
     appliedPolicies: appliedPolicies2,
     isCollectionBye,
+    usePublishState: usePublishState2,
+    publishStatus: publishStatus2,
     matchUpTieId,
     isRoundRobin: isRoundRobin2,
     roundProfile: roundProfile2,
@@ -7179,8 +7216,10 @@ function getAllStructureMatchUps({
       scheduleVisibilityFilters: scheduleVisibilityFilters2,
       afterRecoveryTimes,
       tournamentRecord,
+      usePublishState: usePublishState2,
       scheduleTiming,
       matchUpFormat,
+      publishStatus: publishStatus2,
       matchUpType,
       matchUp,
       event: event2
@@ -7303,7 +7342,7 @@ function getAllStructureMatchUps({
       Object.assign(matchUpWithContext, makeDeepCopy({ sides }, true, true));
     }
     if (tournamentParticipants && matchUpWithContext.sides) {
-      const participantAttributes = policyDefinitions?.[POLICY_TYPE_PARTICIPANT];
+      const participantAttributes = appliedPolicies2?.[POLICY_TYPE_PARTICIPANT];
       const getMappedParticipant = (participantId) => {
         const participant = participantMap?.[participantId]?.participant;
         return participant && attributeFilter({
@@ -7419,6 +7458,8 @@ function getAllStructureMatchUps({
             additionalContext: additionalContext2,
             appliedPolicies: appliedPolicies2,
             isCollectionBye: isCollectionBye2,
+            usePublishState: usePublishState2,
+            publishStatus: publishStatus2,
             matchUpTieId: matchUpTieId2,
             isRoundRobin: isRoundRobin2,
             roundProfile: roundProfile2,
@@ -7456,11 +7497,13 @@ function getStructureMatchUps({
   afterRecoveryTimes,
   policyDefinitions,
   tournamentRecord,
+  usePublishState,
   matchUpFilters,
   contextFilters,
   contextContent,
   participantMap,
   scheduleTiming,
+  publishStatus,
   contextProfile,
   drawDefinition,
   exitProfiles,
@@ -7481,13 +7524,15 @@ function getStructureMatchUps({
     afterRecoveryTimes,
     policyDefinitions,
     tournamentRecord,
-    drawDefinition,
+    usePublishState,
     matchUpFilters,
     contextFilters,
-    contextProfile,
     contextContent,
     participantMap,
     scheduleTiming,
+    publishStatus,
+    contextProfile,
+    drawDefinition,
     exitProfiles,
     matchUpsMap,
     structure,
@@ -7583,12 +7628,14 @@ function getDrawMatchUps(params) {
     afterRecoveryTimes,
     policyDefinitions,
     tournamentRecord,
+    usePublishState,
     contextFilters,
-    contextProfile,
-    drawDefinition,
     matchUpFilters,
     scheduleTiming,
     participantMap,
+    publishStatus,
+    contextProfile,
+    drawDefinition,
     nextMatchUps,
     inContext,
     context,
@@ -7643,9 +7690,11 @@ function getDrawMatchUps(params) {
       afterRecoveryTimes,
       policyDefinitions,
       tournamentRecord,
+      usePublishState,
+      contextContent,
       participantMap,
       scheduleTiming,
-      contextContent,
+      publishStatus,
       contextProfile,
       drawDefinition,
       exitProfiles,
@@ -7962,9 +8011,10 @@ function tournamentMatchUps(params) {
     useParticipantMap,
     tournamentRecord,
     inContext = true,
+    usePublishState,
     contextFilters,
-    contextProfile,
     matchUpFilters,
+    contextProfile,
     nextMatchUps,
     context
   } = params;
@@ -8002,6 +8052,7 @@ function tournamentMatchUps(params) {
       afterRecoveryTimes,
       policyDefinitions,
       tournamentRecord,
+      usePublishState,
       contextFilters,
       contextProfile,
       contextContent,
@@ -8047,9 +8098,10 @@ function eventMatchUps(params) {
     policyDefinitions,
     useParticipantMap,
     tournamentRecord,
+    usePublishState,
     contextFilters,
-    contextProfile,
     matchUpFilters,
+    contextProfile,
     nextMatchUps,
     tournamentId,
     inContext,
@@ -8092,6 +8144,7 @@ function eventMatchUps(params) {
       contextProfile,
       event
     });
+  const publishStatus = getEventPublishStatus({ event });
   const drawDefinitions = event.drawDefinitions ?? [];
   const eventResult = drawDefinitions.reduce((results, drawDefinition) => {
     const drawMatchUpsResult = getDrawMatchUps({
@@ -8103,12 +8156,14 @@ function eventMatchUps(params) {
       afterRecoveryTimes,
       policyDefinitions,
       tournamentRecord,
-      drawDefinition,
+      usePublishState,
       contextContent,
       contextFilters,
-      contextProfile,
       matchUpFilters,
       participantMap,
+      publishStatus,
+      contextProfile,
+      drawDefinition,
       nextMatchUps,
       inContext,
       event
@@ -8134,12 +8189,14 @@ function drawMatchUps({
   policyDefinitions,
   useParticipantMap,
   tournamentRecord,
+  usePublishState,
   contextFilters,
-  contextProfile,
   contextContent,
-  drawDefinition,
   matchUpFilters,
   participantMap,
+  publishStatus,
+  contextProfile,
+  drawDefinition,
   nextMatchUps,
   tournamentId,
   inContext,
@@ -8190,12 +8247,14 @@ function drawMatchUps({
     afterRecoveryTimes,
     policyDefinitions,
     tournamentRecord,
+    usePublishState,
     participantMap,
-    drawDefinition,
-    matchUpFilters,
+    contextContent,
     contextFilters,
+    matchUpFilters,
+    publishStatus,
     contextProfile,
-    contextContent,
+    drawDefinition,
     nextMatchUps,
     inContext,
     event
@@ -10836,6 +10895,11 @@ function getMatchUpDailyLimits({
   return { matchUpDailyLimits: dailyLimits };
 }
 
+function getDrawPublishStatus({ drawDetails, drawId }) {
+  const details = drawDetails?.[drawId]?.publishingDetail;
+  return details?.published;
+}
+
 function scheduledSortedMatchUps({
   schedulingProfile,
   matchUps = []
@@ -10977,6 +11041,7 @@ function competitionMatchUps({
   participantsProfile,
   tournamentRecords,
   policyDefinitions,
+  usePublishState,
   matchUpFilters,
   contextFilters,
   nextMatchUps,
@@ -10992,6 +11057,7 @@ function competitionMatchUps({
       participantsProfile,
       policyDefinitions,
       tournamentRecord,
+      usePublishState,
       matchUpFilters,
       contextFilters,
       nextMatchUps,
@@ -11037,11 +11103,10 @@ function competitionScheduleMatchUps(params) {
     status = PUBLIC,
     sortCourtsData
   } = params;
-  const timeItem = usePublishState ? getTournamentTimeItem({
+  const tournamentPublishStatus = usePublishState ? getTournamentTimeItem({
     tournamentRecord: tournamentRecords[activeTournamentId ?? getTournamentId()],
     itemType: `${PUBLISH}.${STATUS$1}`
-  }).timeItem : void 0;
-  const publishStatus = timeItem?.itemValue?.[status];
+  }).timeItem?.itemValue?.[status] : void 0;
   const allCompletedMatchUps = alwaysReturnCompleted ? competitionMatchUps({
     ...params,
     matchUpFilters: {
@@ -11050,7 +11115,7 @@ function competitionScheduleMatchUps(params) {
     },
     contextFilters: params.contextFilters
   }).completedMatchUps : [];
-  if (usePublishState && (!publishStatus || !Object.keys(publishStatus).length)) {
+  if (usePublishState && (!tournamentPublishStatus || !Object.keys(tournamentPublishStatus).length)) {
     return {
       completedMatchUps: allCompletedMatchUps,
       dateMatchUps: [],
@@ -11058,7 +11123,12 @@ function competitionScheduleMatchUps(params) {
       venues
     };
   }
-  const publishedDrawIds = usePublishState ? getCompetitionPublishedDrawIds({ tournamentRecords }).drawIds : void 0;
+  let publishedDrawIds, detailsMap;
+  if (usePublishState) {
+    ({ drawIds: publishedDrawIds, detailsMap } = getCompetitionPublishedDrawDetails({
+      tournamentRecords
+    }));
+  }
   if (publishedDrawIds?.length) {
     if (!params.contextFilters)
       params.contextFilters = {};
@@ -11070,34 +11140,34 @@ function competitionScheduleMatchUps(params) {
       );
     }
   }
-  if (publishStatus?.eventIds?.length) {
+  if (tournamentPublishStatus?.eventIds?.length) {
     if (!params.matchUpFilters)
       params.matchUpFilters = {};
     if (params.matchUpFilters?.eventIds) {
       if (!params.matchUpFilters.eventIds.length) {
-        params.matchUpFilters.eventIds = publishStatus.eventIds;
+        params.matchUpFilters.eventIds = tournamentPublishStatus.eventIds;
       } else {
         params.matchUpFilters.eventIds = params.matchUpFilters.eventIds.filter(
-          (eventId) => publishStatus.eventIds.includes(eventId)
+          (eventId) => tournamentPublishStatus.eventIds.includes(eventId)
         );
       }
     } else {
-      params.matchUpFilters.eventIds = publishStatus.eventIds;
+      params.matchUpFilters.eventIds = tournamentPublishStatus.eventIds;
     }
   }
-  if (publishStatus?.scheduledDates?.length) {
+  if (tournamentPublishStatus?.scheduledDates?.length) {
     if (!params.matchUpFilters)
       params.matchUpFilters = {};
     if (params.matchUpFilters.scheduledDates) {
       if (!params.matchUpFilters.scheduledDates.length) {
-        params.matchUpFilters.scheduledDates = publishStatus.scheduledDates;
+        params.matchUpFilters.scheduledDates = tournamentPublishStatus.scheduledDates;
       } else {
         params.matchUpFilters.scheduledDates = params.matchUpFilters.scheduledDates.filter(
-          (scheduledDate) => publishStatus.scheduledDates.includes(scheduledDate)
+          (scheduledDate) => tournamentPublishStatus.scheduledDates.includes(scheduledDate)
         );
       }
     } else {
-      params.matchUpFilters.scheduledDates = publishStatus.scheduledDates;
+      params.matchUpFilters.scheduledDates = tournamentPublishStatus.scheduledDates;
     }
   }
   if (alwaysReturnCompleted) {
@@ -11116,10 +11186,48 @@ function competitionScheduleMatchUps(params) {
     matchUpFilters: params.matchUpFilters,
     contextFilters: params.contextFilters
   });
-  const relevantMatchUps = [
+  let relevantMatchUps = [
     ...upcomingMatchUps ?? [],
     ...pendingMatchUps ?? []
   ];
+  if (detailsMap && Object.keys(detailsMap).length) {
+    relevantMatchUps = relevantMatchUps.filter((matchUp) => {
+      const { drawId, structureId, stage } = matchUp;
+      if (!detailsMap[drawId])
+        return false;
+      if (detailsMap[drawId].stageDetails) {
+        const stageKeys = Object.keys(detailsMap[drawId].stageDetails);
+        const unpublishedStages = stageKeys.filter(
+          (stage2) => !detailsMap[drawId].stageDetails[stage2].published
+        );
+        const publishedStages = stageKeys.filter(
+          (stage2) => detailsMap[drawId].stageDetails[stage2].published
+        );
+        if (unpublishedStages.length && unpublishedStages.includes(stage))
+          return false;
+        if (publishedStages.length && publishedStages.includes(stage))
+          return true;
+        return unpublishedStages.length && !unpublishedStages.includes(stage) && !publishedStages.length;
+      }
+      if (detailsMap[drawId].structureDetails) {
+        const structureIdKeys = Object.keys(
+          detailsMap[drawId].structureDetails
+        );
+        const unpublishedStructureIds = structureIdKeys.filter(
+          (structureId2) => !detailsMap[drawId].structureDetails[structureId2].published
+        );
+        const publishedStructureIds = structureIdKeys.filter(
+          (structureId2) => detailsMap[drawId].structureDetails[structureId2].published
+        );
+        if (unpublishedStructureIds.length && unpublishedStructureIds.includes(structureId))
+          return false;
+        if (publishedStructureIds.length && publishedStructureIds.includes(structureId))
+          return true;
+        return unpublishedStructureIds.length && !unpublishedStructureIds.includes(structureId) && !publishedStructureIds.length;
+      }
+      return true;
+    });
+  }
   const dateMatchUps = sortDateMatchUps ? scheduledSortedMatchUps({ matchUps: relevantMatchUps, schedulingProfile }) : relevantMatchUps;
   const courtsData = courts?.map((court) => {
     const matchUps = getCourtMatchUps(court);
@@ -11130,11 +11238,11 @@ function competitionScheduleMatchUps(params) {
     };
   });
   const result = {
-    courtsData,
     completedMatchUps: alwaysReturnCompleted ? allCompletedMatchUps : completedMatchUps,
     // completed matchUps for the filter date
     dateMatchUps,
     // all incomplete matchUps for the filter date
+    courtsData,
     groupInfo,
     venues
   };
@@ -11158,26 +11266,28 @@ function competitionScheduleMatchUps(params) {
     }) : courtMatchUps;
   }
 }
-function getCompetitionPublishedDrawIds({
+function getCompetitionPublishedDrawDetails({
   tournamentRecords
 }) {
   const drawIds = [];
+  const detailsMap = {};
   for (const tournamentRecord of Object.values(tournamentRecords)) {
     for (const event of tournamentRecord.events ?? []) {
-      const { timeItem } = getEventTimeItem({
-        itemType: `${PUBLISH}.${STATUS$1}`,
-        event
-      });
-      const pubState = timeItem?.itemValue?.[PUBLIC];
-      if (pubState?.drawIds?.length) {
-        drawIds.push(...pubState.drawIds);
-      } else {
-        const eventDrawIds = (event.drawDefinitions ?? []).map(({ drawId }) => drawId).filter(Boolean);
-        drawIds.push(...eventDrawIds);
+      const eventPubStatus = getEventPublishStatus({ event });
+      const drawDetails = eventPubStatus?.drawDetails;
+      if (isObject(drawDetails)) {
+        Object.assign(detailsMap, drawDetails);
+        drawIds.push(
+          ...Object.keys(drawDetails).filter(
+            (drawId) => getDrawPublishStatus({ drawId, drawDetails })
+          )
+        );
+      } else if (eventPubStatus?.drawIds?.length) {
+        drawIds.push(...eventPubStatus.drawIds);
       }
     }
   }
-  return { drawIds };
+  return { drawIds, detailsMap };
 }
 
 const { stageOrder } = drawDefinitionConstants;
@@ -11865,13 +11975,8 @@ function getMatchUpDependencies(params) {
 }
 
 function getEventPublishStatuses({ event }) {
-  const itemType = `${PUBLISH}.${STATUS$1}`;
-  const { timeItem } = getTimeItem({
-    element: event,
-    itemType
-  });
-  if (timeItem?.itemValue?.PUBLIC) {
-    const { drawIds: publishedDrawIds = [], seeding } = timeItem.itemValue.PUBLIC || {};
+  const eventPubStatus = getEventPublishStatus({ event });
+  if (eventPubStatus) {
     const publishedSeeding = {
       published: void 0,
       // seeding can be present for all entries in an event when no flights have been defined
@@ -11879,9 +11984,13 @@ function getEventPublishStatuses({ event }) {
       drawIds: []
       // seeding can be specific to drawIds
     };
-    if (seeding) {
-      Object.assign(publishedSeeding, timeItem.itemValue.PUBLIC.seeding);
+    if (eventPubStatus.seeding) {
+      Object.assign(publishedSeeding, eventPubStatus.seeding);
     }
+    const { drawDetails, drawIds } = eventPubStatus;
+    const publishedDrawIds = drawDetails && Object.keys(drawDetails).filter(
+      (drawId) => getDrawPublishStatus({ drawDetails, drawId })
+    ) || drawIds || [];
     return {
       publishedDrawIds,
       publishedSeeding
@@ -11967,6 +12076,10 @@ function getEventSeedAssignments({
   return eventSeedAssignments;
 }
 
+function stringSort(a, b) {
+  return (a || "").localeCompare(b || "");
+}
+
 function processEventEntry({
   convertExtensions,
   seedAssignments,
@@ -12838,7 +12951,7 @@ function getParticipantEntries(params) {
             const itemIsPrior = consideredMinutes >= scheduledMinutes;
             const timeOverlap = scheduledMinutesDifference && !isNaN(scheduledMinutesDifference) ? minutesDifference <= scheduledMinutesDifference : itemIsPrior && timeStringMinutes(consideredItem.scheduledTime) < timeStringMinutes(notBeforeTime);
             if (timeOverlap && !(bothPotential && sameDraw) && itemIsPrior) {
-              const key = [scheduleItem.matchUpId, consideredItem.matchUpId].sort().join("|");
+              const key = [scheduleItem.matchUpId, consideredItem.matchUpId].sort(stringSort).join("|");
               participantAggregator.scheduleConflicts[key] = {
                 priorScheduledMatchUpId: scheduleItem.matchUpId,
                 matchUpIdWithConflict: consideredItem.matchUpId
@@ -14920,7 +15033,9 @@ function getDrawData(params) {
     policyDefinitions,
     tournamentRecord,
     inContext = true,
+    usePublishState,
     drawDefinition,
+    publishStatus,
     noDeepCopy,
     sortConfig,
     context,
@@ -14992,6 +15107,8 @@ function getDrawData(params) {
         tournamentParticipants,
         policyDefinitions,
         tournamentRecord,
+        usePublishState,
+        publishStatus,
         drawDefinition,
         inContext,
         structure,
@@ -15105,11 +15222,7 @@ function getEventData(params) {
     return { error: MISSING_EVENT };
   const { eventId } = event;
   const { tournamentId, endDate } = tournamentRecord;
-  const { timeItem } = getEventTimeItem({
-    itemType: `${PUBLISH}.${STATUS$1}`,
-    event
-  });
-  const publishStatus = timeItem?.itemValue?.[status];
+  const publishStatus = getEventPublishStatus({ event, status });
   const { participants: tournamentParticipants } = getParticipants({
     withGroupings: true,
     withEvents: false,
@@ -15118,9 +15231,51 @@ function getEventData(params) {
     // order is important!!
     tournamentRecord
   });
-  const stageFilter = ({ stage }) => !usePublishState || !publishStatus?.stages?.length || publishStatus.stages.includes(stage);
-  const structureFilter = ({ structureId }) => !usePublishState || !publishStatus?.structureIds?.length || publishStatus.structureIds.includes(structureId);
-  const drawFilter = ({ drawId }) => !usePublishState || !publishStatus?.drawIds?.length || publishStatus.drawIds.includes(drawId);
+  const stageFilter = ({ stage, drawId }) => {
+    if (!usePublishState)
+      return true;
+    const stageDetails = publishStatus?.drawDetails?.[drawId]?.stageDetails;
+    if (!stageDetails || !Object.keys(stageDetails).length)
+      return true;
+    return stageDetails[stage]?.published;
+  };
+  const structureFilter = ({ structureId, drawId }) => {
+    if (!usePublishState)
+      return true;
+    const structureDetails = publishStatus?.drawDetails?.[drawId]?.structureDetails;
+    if (!structureDetails || !Object.keys(structureDetails).length)
+      return true;
+    return structureDetails[structureId]?.published;
+  };
+  const drawFilter = ({ drawId }) => {
+    if (!usePublishState)
+      return true;
+    if (publishStatus.drawDetails) {
+      return publishStatus.drawDetails[drawId]?.publishingDetail?.published;
+    } else if (publishStatus.drawIds) {
+      return publishStatus.drawIds.includes(drawId);
+    }
+    return true;
+  };
+  const roundLimitMapper = ({ drawId, structure }) => {
+    if (!usePublishState)
+      return structure;
+    const roundLimit = publishStatus?.drawDetails?.[drawId]?.structureDetails?.[structure.structureId]?.roundLimit;
+    if (isConvertableInteger(roundLimit)) {
+      const roundNumbers = generateRange(1, roundLimit + 1);
+      const roundMatchUps = {};
+      const roundProfile = {};
+      for (const roundNumber of roundNumbers) {
+        if (structure.roundMatchUps[roundNumber]) {
+          roundMatchUps[roundNumber] = structure.roundMatchUps[roundNumber];
+          roundProfile[roundNumber] = structure.roundProfile[roundNumber];
+        }
+      }
+      structure.roundMatchUps = roundMatchUps;
+      structure.roundProfile = roundProfile;
+    }
+    return structure;
+  };
   const drawDefinitions = event.drawDefinitions || [];
   const drawsData = drawDefinitions.filter(drawFilter).map(
     (drawDefinition) => (({ drawInfo, structures }) => ({
@@ -15134,15 +15289,24 @@ function getEventData(params) {
         noDeepCopy: true,
         policyDefinitions,
         tournamentRecord,
+        usePublishState,
         drawDefinition,
+        publishStatus,
         sortConfig,
         event
       })
     )
-  ).map(({ structures, ...drawData }) => ({
-    ...drawData,
-    structures: structures?.filter(structureFilter)?.filter(stageFilter)
-  })).filter((drawData) => drawData.structures?.length);
+  ).map(({ structures, ...drawData }) => {
+    const filteredStructures = structures?.filter(
+      ({ stage, structureId }) => structureFilter({ structureId, drawId: drawData.drawId }) && stageFilter({ stage, drawId: drawData.drawId })
+    ).map(
+      (structure) => roundLimitMapper({ drawId: drawData.drawId, structure })
+    );
+    return {
+      ...drawData,
+      structures: filteredStructures
+    };
+  }).filter((drawData) => drawData.structures?.length);
   const { tournamentInfo } = getTournamentInfo({ tournamentRecord });
   const venues = tournamentRecord.venues || [];
   const venuesData = venues.map(
@@ -15188,10 +15352,7 @@ function getEventData(params) {
     eventInfo,
     drawsData
   };
-  eventData.eventInfo.publish = {
-    createdAt: timeItem?.createdAt,
-    state: timeItem?.itemValue
-  };
+  eventData.eventInfo.publish = publishStatus;
   return { ...SUCCESS, eventData };
 }