tods-competition-factory 1.8.6 → 1.8.8

package/dist/index.mjs

@@ -945,6 +945,10 @@ const INVALID_OBJECT = {
   message: "Invalid object",
   code: "ERR_INVALID_OBJECT"
 };
+const INVALID_GENDER = {
+  message: "Invalid gender",
+  code: "ERR_INVALID_GENDER"
+};
 const INVALID_CATEGORY = {
   message: "Invalid category",
   code: "ERR_INVALID_CATEGORY"
@@ -1062,6 +1066,7 @@ const errorConditionConstants = {
   INVALID_ENTRIES,
   INVALID_EVENT_TYPE,
   INVALID_GAME_SCORES,
+  INVALID_GENDER,
   INVALID_MATCHUP_FORMAT,
   INVALID_MATCHUP_STATUS,
   INVALID_MATCHUP_STATUS_BYE,
@@ -2375,7 +2380,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.8.6";
+  return "1.8.8";
 }
 
 function getObjectTieFormat(obj) {
@@ -2938,6 +2943,11 @@ function validateCollectionDefinition({
   }
   if (checkGender && referenceGender && gender && [GenderEnum.Male, GenderEnum.Female].includes(referenceGender) && referenceGender !== gender) {
     errors.push(`Invalid gender: ${gender}`);
+    return decorateResult({
+      context: { referenceGender, gender },
+      result: { error: INVALID_GENDER },
+      stack
+    });
   }
   if (checkCategory && referenceCategory && category) {
     const result = categoryCanContain({
@@ -35135,326 +35145,6 @@ function getMatchUpDailyLimitsUpdate$1({ tournamentRecords }) {
   });
 }
 
-const { stageOrder } = drawDefinitionConstants;
-function getProfileRounds({
-  tournamentRecords,
-  schedulingProfile,
-  tournamentRecord,
-  withRoundId
-}) {
-  if (tournamentRecord && !tournamentRecords) {
-    if (typeof tournamentRecord !== "object") {
-      return { error: INVALID_TOURNAMENT_RECORD };
-    } else {
-      tournamentRecords = { [tournamentRecord.tournamentId]: tournamentRecord };
-    }
-  }
-  if (schedulingProfile) {
-    const profileValidity = validateSchedulingProfile({
-      tournamentRecords,
-      schedulingProfile
-    });
-    if (profileValidity.error)
-      return profileValidity;
-  }
-  if (!schedulingProfile && tournamentRecords) {
-    const result = getSchedulingProfile$1({ tournamentRecords });
-    if (result.error)
-      return result;
-    schedulingProfile = result.schedulingProfile;
-  }
-  if (!schedulingProfile)
-    return { error: NOT_FOUND };
-  const segmentedRounds = {};
-  const profileRounds = schedulingProfile.map(
-    ({ venues, scheduleDate }) => venues.map(
-      ({ rounds }) => rounds.map((round) => {
-        const roundRef = getRoundId(round);
-        if (roundRef.roundSegment?.segmentsCount) {
-          segmentedRounds[roundRef.id] = roundRef.roundSegment.segmentsCount;
-        }
-        return definedAttributes({
-          id: withRoundId ? roundRef.id : void 0,
-          scheduleDate,
-          ...roundRef
-        });
-      })
-    )
-  ).flat(Infinity);
-  return { profileRounds, segmentedRounds };
-}
-function getRoundId(obj) {
-  const {
-    containerStructureId,
-    roundSegment,
-    isRoundRobin,
-    tournamentId,
-    roundNumber,
-    structureId,
-    eventId,
-    drawId
-  } = obj;
-  const relevantStructureId = isRoundRobin ? containerStructureId : structureId;
-  const id = [
-    tournamentId,
-    // 1
-    eventId,
-    // 2
-    drawId,
-    // 3
-    relevantStructureId,
-    // 4
-    roundNumber
-    // 5
-  ].join("|");
-  return definedAttributes({
-    id,
-    roundSegment,
-    tournamentId,
-    eventId,
-    drawId,
-    structureId: relevantStructureId,
-    roundNumber
-  });
-}
-function getRoundProfile(matchUps) {
-  const matchUpsCount = matchUps.length;
-  const byeCount = matchUps.filter(({ sides }) => sides?.some(({ bye }) => bye)).length || 0;
-  const completedCount = matchUps.filter(
-    ({ winningSide, matchUpStatus }) => winningSide || completedMatchUpStatuses.includes(matchUpStatus)
-  ).length || 0;
-  const scheduledCount = matchUps.filter(
-    ({ schedule }) => schedule?.scheduledDate && schedule?.scheduledTime
-  ).length || 0;
-  const consideredCount = matchUpsCount - byeCount;
-  const isComplete = consideredCount === completedCount;
-  const unscheduledCount = consideredCount - scheduledCount;
-  const incompleteCount = consideredCount - scheduledCount;
-  const isScheduled = consideredCount === scheduledCount;
-  return {
-    unscheduledCount,
-    incompleteCount,
-    scheduledCount,
-    completedCount,
-    matchUpsCount,
-    isScheduled,
-    isComplete,
-    byeCount
-  };
-}
-function getRounds({
-  excludeScheduleDateProfileRounds,
-  excludeScheduledRounds,
-  excludeCompletedRounds,
-  inContextMatchUps,
-  tournamentRecords,
-  schedulingProfile,
-  tournamentRecord,
-  withSplitRounds,
-  matchUpFilters,
-  withRoundId,
-  context
-}) {
-  if (inContextMatchUps && !Array.isArray(
-    inContextMatchUps || typeof inContextMatchUps[0] !== "object"
-  )) {
-    return { error: INVALID_VALUES, inContextMatchUps };
-  }
-  if (tournamentRecord && !tournamentRecords) {
-    if (typeof tournamentRecord !== "object") {
-      return { error: INVALID_TOURNAMENT_RECORD };
-    } else {
-      tournamentRecords = { [tournamentRecord.tournamentId]: tournamentRecord };
-    }
-  }
-  const noTournamentRecords = typeof tournamentRecords !== "object" || !Object.keys(tournamentRecords).length;
-  const needsTournamentRecords = !inContextMatchUps || !schedulingProfile && (excludeScheduleDateProfileRounds || excludeCompletedRounds || schedulingProfile || withSplitRounds);
-  if (needsTournamentRecords && noTournamentRecords)
-    return { error: MISSING_TOURNAMENT_RECORDS };
-  const events = Object.values(tournamentRecords ?? {}).map(({ events: events2 }) => events2).flat();
-  const { segmentedRounds, profileRounds } = tournamentRecords && (excludeScheduleDateProfileRounds || excludeCompletedRounds || schedulingProfile || withSplitRounds) && getProfileRounds({ tournamentRecords, schedulingProfile }) || {};
-  const profileRoundsMap = excludeScheduleDateProfileRounds && Object.assign(
-    {},
-    ...profileRounds.map((profile) => ({ [profile.id]: profile }))
-  );
-  const consideredMatchUps = inContextMatchUps || tournamentRecords && allCompetitionMatchUps({ tournamentRecords, matchUpFilters })?.matchUps || [];
-  const excludedRounds = [];
-  const rounds = consideredMatchUps && Object.values(
-    consideredMatchUps.reduce((rounds2, matchUp) => {
-      const id = getRoundId(matchUp).id;
-      const segmentsCount = segmentedRounds?.[id];
-      const matchUps = [...rounds2[id]?.matchUps ?? [], matchUp];
-      const {
-        containerStructureId,
-        stageSequence,
-        structureName,
-        tournamentId,
-        isRoundRobin,
-        matchUpType,
-        roundNumber,
-        roundOffset,
-        structureId,
-        eventName,
-        roundName,
-        drawName,
-        eventId,
-        drawId
-      } = matchUp;
-      const relevantStructureId = isRoundRobin ? containerStructureId : structureId;
-      return {
-        ...rounds2,
-        [id]: {
-          id: withRoundId ? id : void 0,
-          structureId: relevantStructureId,
-          stageSequence,
-          segmentsCount,
-          structureName,
-          tournamentId,
-          matchUpType,
-          roundNumber,
-          roundOffset,
-          eventName,
-          roundName,
-          drawName,
-          matchUps,
-          eventId,
-          drawId
-        }
-      };
-    }, {})
-  ).map((round) => {
-    const { minFinishingSum, winnerFinishingPositionRange } = getFinishingPositionDetails(round.matchUps);
-    const segmentsCount = round.segmentsCount;
-    if (segmentsCount) {
-      const chunkSize = round.matchUps.length / segmentsCount;
-      const sortedMatchUps = chunkArray(
-        round.matchUps.sort((a, b) => a.roundPosition - b.roundPosition),
-        chunkSize
-      );
-      return sortedMatchUps.map((matchUps, i) => {
-        const {
-          unscheduledCount: unscheduledCount2,
-          incompleteCount: incompleteCount2,
-          matchUpsCount: matchUpsCount2,
-          isScheduled: isScheduled2,
-          isComplete: isComplete2,
-          byeCount: byeCount2
-        } = getRoundProfile(matchUps);
-        const roundTiming2 = getRoundTiming({
-          matchUps: round.matchUps,
-          tournamentRecords,
-          events,
-          round
-        });
-        return definedAttributes({
-          ...round,
-          ...context,
-          roundSegment: { segmentsCount, segmentNumber: i + 1 },
-          winnerFinishingPositionRange,
-          unscheduledCount: unscheduledCount2,
-          incompleteCount: incompleteCount2,
-          minFinishingSum,
-          matchUpsCount: matchUpsCount2,
-          isScheduled: isScheduled2,
-          roundTiming: roundTiming2,
-          isComplete: isComplete2,
-          byeCount: byeCount2,
-          matchUps
-        });
-      });
-    }
-    const {
-      unscheduledCount,
-      incompleteCount,
-      matchUpsCount,
-      isScheduled,
-      isComplete,
-      byeCount
-    } = getRoundProfile(round.matchUps);
-    const roundTiming = getRoundTiming({
-      matchUps: round.matchUps,
-      tournamentRecords,
-      events,
-      round
-    });
-    return definedAttributes({
-      ...round,
-      ...context,
-      winnerFinishingPositionRange,
-      unscheduledCount,
-      incompleteCount,
-      minFinishingSum,
-      matchUpsCount,
-      isScheduled,
-      roundTiming,
-      isComplete,
-      byeCount
-    });
-  }).flat().filter((round) => {
-    if (excludeScheduleDateProfileRounds) {
-      const scheduleDate = extractDate(excludeScheduleDateProfileRounds);
-      const roundId = withRoundId ? round.id : getRoundId(round).id;
-      if (scheduleDate && profileRoundsMap[roundId] && extractDate(profileRoundsMap[roundId].scheduleDate) === scheduleDate) {
-        return false;
-      }
-    }
-    const { isComplete, isScheduled } = round;
-    const keepComplete = !excludeCompletedRounds || !isComplete;
-    const keepScheduled = !excludeScheduledRounds || !isScheduled;
-    const keepRound = keepComplete && keepScheduled;
-    if (!keepRound)
-      excludedRounds.push(round);
-    return keepRound;
-  }).sort(roundSort) || [];
-  return { ...SUCCESS, rounds, excludedRounds };
-}
-function getRoundTiming({ round, matchUps, events, tournamentRecords }) {
-  const event = events.find((event2) => event2.eventId === round.eventId);
-  const { eventType, category, categoryType } = event || {};
-  const { categoryName, ageCategoryCode } = category || {};
-  const formatCounts = instanceCount(
-    matchUps.map(({ matchUpFormat }) => matchUpFormat)
-  );
-  let roundMinutes = 0;
-  Object.keys(formatCounts).forEach((matchUpFormat) => {
-    const formatCount = formatCounts[matchUpFormat];
-    const result = findMatchUpFormatTiming({
-      categoryName: categoryName || ageCategoryCode,
-      tournamentId: round.tournamentId,
-      eventId: round.eventId,
-      tournamentRecords,
-      matchUpFormat,
-      categoryType,
-      eventType
-    });
-    if (result.error)
-      return result;
-    const formatMinutes = result.averageMinutes * formatCount;
-    if (!isNaN(roundMinutes))
-      roundMinutes += formatMinutes;
-    return void 0;
-  });
-  return { roundMinutes };
-}
-function roundSort(a, b) {
-  return a.eventName.localeCompare(b.eventName) || a.eventId.localeCompare(b.eventId) || (stageOrder[a?.stage] || 0) - (stageOrder[b?.stage] || 0) || b.matchUpsCount - a.matchUpsCount || `${a.stageSequence}-${a.roundNumber}-${a.minFinishingSum}`.localeCompare(
-    `${b.stageSequence}-${b.roundNumber}-${b.minFinishingSum}`
-  );
-}
-function getFinishingPositionDetails(matchUps) {
-  return (matchUps || []).reduce(
-    (foo, matchUp) => {
-      const sum = (matchUp.finishingPositionRange?.winner || []).reduce(
-        (a, b) => a + b,
-        0
-      );
-      const winnerFinishingPositionRange = (matchUp.finishingPositionRange?.winner || []).join("-") || "";
-      return !foo.minFinishingSum || sum < foo.minFinishingSum ? { minFinishingSum: sum, winnerFinishingPositionRange } : foo;
-    },
-    { minFinishingSum: 0, winnerFinishingPositionRange: "" }
-  );
-}
-
 function bulkUpdateCourtAssignments({
   tournamentRecords,
   courtAssignments,
@@ -35885,6 +35575,155 @@ function reorderUpcomingMatchUps(params) {
   }
 }
 
+function getRoundId(obj) {
+  const {
+    containerStructureId,
+    roundSegment,
+    isRoundRobin,
+    tournamentId,
+    roundNumber,
+    structureId,
+    eventId,
+    drawId
+  } = obj;
+  const relevantStructureId = isRoundRobin ? containerStructureId : structureId;
+  const id = [
+    tournamentId,
+    // 1
+    eventId,
+    // 2
+    drawId,
+    // 3
+    relevantStructureId,
+    // 4
+    roundNumber
+    // 5
+  ].join("|");
+  return definedAttributes({
+    structureId: relevantStructureId,
+    roundSegment,
+    tournamentId,
+    roundNumber,
+    eventId,
+    drawId,
+    id
+  });
+}
+function getRoundTiming({ round, matchUps, events, tournamentRecords }) {
+  const event = events.find((event2) => event2.eventId === round.eventId);
+  const { eventType, category, categoryType } = event || {};
+  const { categoryName, ageCategoryCode } = category || {};
+  const formatCounts = instanceCount(
+    matchUps.map(({ matchUpFormat }) => matchUpFormat)
+  );
+  let roundMinutes = 0;
+  Object.keys(formatCounts).forEach((matchUpFormat) => {
+    const formatCount = formatCounts[matchUpFormat];
+    const result = findMatchUpFormatTiming({
+      categoryName: categoryName || ageCategoryCode,
+      tournamentId: round.tournamentId,
+      eventId: round.eventId,
+      tournamentRecords,
+      matchUpFormat,
+      categoryType,
+      eventType
+    });
+    if (result.error)
+      return result;
+    const formatMinutes = result.averageMinutes * formatCount;
+    if (!isNaN(roundMinutes))
+      roundMinutes += formatMinutes;
+    return void 0;
+  });
+  return { roundMinutes };
+}
+function getFinishingPositionDetails(matchUps) {
+  return (matchUps || []).reduce(
+    (foo, matchUp) => {
+      const sum = (matchUp.finishingPositionRange?.winner || []).reduce(
+        (a, b) => a + b,
+        0
+      );
+      const winnerFinishingPositionRange = (matchUp.finishingPositionRange?.winner || []).join("-") || "";
+      return !foo.minFinishingSum || sum < foo.minFinishingSum ? { minFinishingSum: sum, winnerFinishingPositionRange } : foo;
+    },
+    { minFinishingSum: 0, winnerFinishingPositionRange: "" }
+  );
+}
+function getRoundProfile(matchUps) {
+  const matchUpsCount = matchUps.length;
+  const byeCount = matchUps.filter(({ sides }) => sides?.some(({ bye }) => bye)).length || 0;
+  const completedCount = matchUps.filter(
+    ({ winningSide, matchUpStatus }) => winningSide || completedMatchUpStatuses.includes(matchUpStatus)
+  ).length || 0;
+  const scheduledCount = matchUps.filter(
+    ({ schedule }) => schedule?.scheduledDate && schedule?.scheduledTime
+  ).length || 0;
+  const consideredCount = matchUpsCount - byeCount;
+  const isComplete = consideredCount === completedCount;
+  const unscheduledCount = consideredCount - scheduledCount;
+  const incompleteCount = consideredCount - scheduledCount;
+  const isScheduled = consideredCount === scheduledCount;
+  return {
+    unscheduledCount,
+    incompleteCount,
+    scheduledCount,
+    completedCount,
+    matchUpsCount,
+    isScheduled,
+    isComplete,
+    byeCount
+  };
+}
+
+function getProfileRounds({
+  tournamentRecords,
+  schedulingProfile,
+  tournamentRecord,
+  withRoundId
+}) {
+  if (tournamentRecord && !tournamentRecords) {
+    if (typeof tournamentRecord !== "object") {
+      return { error: INVALID_TOURNAMENT_RECORD };
+    } else {
+      tournamentRecords = { [tournamentRecord.tournamentId]: tournamentRecord };
+    }
+  }
+  if (schedulingProfile) {
+    const profileValidity = validateSchedulingProfile({
+      tournamentRecords,
+      schedulingProfile
+    });
+    if (profileValidity.error)
+      return profileValidity;
+  }
+  if (!schedulingProfile && tournamentRecords) {
+    const result = getSchedulingProfile$1({ tournamentRecords });
+    if (result.error)
+      return result;
+    schedulingProfile = result.schedulingProfile;
+  }
+  if (!schedulingProfile)
+    return { error: NOT_FOUND };
+  const segmentedRounds = {};
+  const profileRounds = schedulingProfile.map(
+    ({ venues, scheduleDate }) => venues.map(
+      ({ rounds }) => rounds.map((round) => {
+        const roundRef = getRoundId(round);
+        if (roundRef.roundSegment?.segmentsCount) {
+          segmentedRounds[roundRef.id] = roundRef.roundSegment.segmentsCount;
+        }
+        return definedAttributes({
+          id: withRoundId ? roundRef.id : void 0,
+          scheduleDate,
+          ...roundRef
+        });
+      })
+    )
+  ).flat(Infinity);
+  return { profileRounds, segmentedRounds };
+}
+
 function addMatchUpScheduleItems$1(params) {
   return addMatchUpScheduleItems$2(params);
 }
@@ -36502,6 +36341,200 @@ function matchUpScheduleChange(params) {
   }
 }
 
+const { stageOrder } = drawDefinitionConstants;
+function roundSort(a, b) {
+  return a.eventName.localeCompare(b.eventName) || a.eventId.localeCompare(b.eventId) || (stageOrder[a?.stage] || 0) - (stageOrder[b?.stage] || 0) || b.matchUpsCount - a.matchUpsCount || `${a.stageSequence}-${a.roundNumber}-${a.minFinishingSum}`.localeCompare(
+    `${b.stageSequence}-${b.roundNumber}-${b.minFinishingSum}`
+  );
+}
+
+function getRounds({
+  excludeScheduleDateProfileRounds,
+  excludeScheduledRounds,
+  excludeCompletedRounds,
+  inContextMatchUps,
+  tournamentRecords,
+  schedulingProfile,
+  tournamentRecord,
+  withSplitRounds,
+  matchUpFilters,
+  scheduleDate,
+  withRoundId,
+  venueId,
+  context
+}) {
+  if (inContextMatchUps && !Array.isArray(
+    inContextMatchUps || typeof inContextMatchUps[0] !== "object"
+  )) {
+    return { error: INVALID_VALUES, inContextMatchUps };
+  }
+  if (tournamentRecord && !tournamentRecords) {
+    if (typeof tournamentRecord !== "object") {
+      return { error: INVALID_TOURNAMENT_RECORD };
+    } else {
+      tournamentRecords = { [tournamentRecord.tournamentId]: tournamentRecord };
+    }
+  }
+  const noTournamentRecords = typeof tournamentRecords !== "object" || !Object.keys(tournamentRecords).length;
+  const needsTournamentRecords = venueId || scheduleDate || !inContextMatchUps || !schedulingProfile && (excludeScheduleDateProfileRounds || excludeCompletedRounds || schedulingProfile || withSplitRounds);
+  if (needsTournamentRecords && noTournamentRecords)
+    return { error: MISSING_TOURNAMENT_RECORDS };
+  const tournamentVenueIds = Object.assign(
+    {},
+    ...Object.values(tournamentRecords ?? {}).map(
+      ({ venues = [], tournamentId }) => ({
+        [tournamentId]: venues?.map(({ venueId: venueId2 }) => venueId2)
+      })
+    )
+  );
+  const events = Object.values(tournamentRecords ?? {}).map(
+    ({ events: events2 = [], tournamentId, startDate, endDate }) => events2.map((event) => ({
+      ...event,
+      validVenueIds: tournamentVenueIds[tournamentId],
+      startDate: event.startDate ?? startDate,
+      endDate: event.endDate ?? endDate
+    }))
+  ).flat();
+  const { segmentedRounds, profileRounds } = tournamentRecords && (excludeScheduleDateProfileRounds || excludeCompletedRounds || schedulingProfile || withSplitRounds) && getProfileRounds({ tournamentRecords, schedulingProfile }) || {};
+  const profileRoundsMap = excludeScheduleDateProfileRounds && Object.assign(
+    {},
+    ...profileRounds.map((profile) => ({ [profile.id]: profile }))
+  );
+  const consideredMatchUps = inContextMatchUps || tournamentRecords && allCompetitionMatchUps({ tournamentRecords, matchUpFilters })?.matchUps || [];
+  const excludedRounds = [];
+  const rounds = consideredMatchUps && Object.values(
+    consideredMatchUps.reduce((rounds2, matchUp) => {
+      const id = getRoundId(matchUp).id;
+      const segmentsCount = segmentedRounds?.[id];
+      const matchUps = [...rounds2[id]?.matchUps ?? [], matchUp];
+      const {
+        containerStructureId,
+        stageSequence,
+        structureName,
+        tournamentId,
+        isRoundRobin,
+        matchUpType,
+        roundNumber,
+        roundOffset,
+        structureId,
+        eventName,
+        roundName,
+        drawName,
+        eventId,
+        drawId
+      } = matchUp;
+      const relevantStructureId = isRoundRobin ? containerStructureId : structureId;
+      return {
+        ...rounds2,
+        [id]: {
+          id: withRoundId ? id : void 0,
+          structureId: relevantStructureId,
+          stageSequence,
+          segmentsCount,
+          structureName,
+          tournamentId,
+          matchUpType,
+          roundNumber,
+          roundOffset,
+          eventName,
+          roundName,
+          drawName,
+          matchUps,
+          eventId,
+          drawId
+        }
+      };
+    }, {})
+  ).map((round) => {
+    const { minFinishingSum, winnerFinishingPositionRange } = getFinishingPositionDetails(round.matchUps);
+    const segmentsCount = round.segmentsCount;
+    if (segmentsCount) {
+      const chunkSize = round.matchUps.length / segmentsCount;
+      const sortedMatchUps = chunkArray(
+        round.matchUps.sort((a, b) => a.roundPosition - b.roundPosition),
+        chunkSize
+      );
+      return sortedMatchUps.map((matchUps, i) => {
+        const {
+          unscheduledCount: unscheduledCount2,
+          incompleteCount: incompleteCount2,
+          matchUpsCount: matchUpsCount2,
+          isScheduled: isScheduled2,
+          isComplete: isComplete2,
+          byeCount: byeCount2
+        } = getRoundProfile(matchUps);
+        const roundTiming2 = getRoundTiming({
+          matchUps: round.matchUps,
+          tournamentRecords,
+          events,
+          round
+        });
+        return definedAttributes({
+          ...round,
+          ...context,
+          roundSegment: { segmentsCount, segmentNumber: i + 1 },
+          winnerFinishingPositionRange,
+          unscheduledCount: unscheduledCount2,
+          incompleteCount: incompleteCount2,
+          minFinishingSum,
+          matchUpsCount: matchUpsCount2,
+          isScheduled: isScheduled2,
+          roundTiming: roundTiming2,
+          isComplete: isComplete2,
+          byeCount: byeCount2,
+          matchUps
+        });
+      });
+    }
+    const {
+      unscheduledCount,
+      incompleteCount,
+      matchUpsCount,
+      isScheduled,
+      isComplete,
+      byeCount
+    } = getRoundProfile(round.matchUps);
+    const roundTiming = getRoundTiming({
+      matchUps: round.matchUps,
+      tournamentRecords,
+      events,
+      round
+    });
+    return definedAttributes({
+      ...round,
+      ...context,
+      winnerFinishingPositionRange,
+      unscheduledCount,
+      incompleteCount,
+      minFinishingSum,
+      matchUpsCount,
+      isScheduled,
+      roundTiming,
+      isComplete,
+      byeCount
+    });
+  }).flat().filter((round) => {
+    if (excludeScheduleDateProfileRounds) {
+      const scheduleDate2 = extractDate(excludeScheduleDateProfileRounds);
+      const roundId = withRoundId ? round.id : getRoundId(round).id;
+      if (scheduleDate2 && profileRoundsMap[roundId] && extractDate(profileRoundsMap[roundId].scheduleDate) === scheduleDate2) {
+        return false;
+      }
+    }
+    const { isComplete, isScheduled } = round;
+    const keepComplete = !excludeCompletedRounds || !isComplete;
+    const keepScheduled = !excludeScheduledRounds || !isScheduled;
+    const event = venueId || scheduleDate ? events?.find(({ eventId }) => eventId === round.eventId) : void 0;
+    const validDate = !scheduleDate || event?.startDate && event?.endDate && new Date(scheduleDate) >= new Date(event?.startDate) && new Date(scheduleDate) <= new Date(event?.endDate);
+    const validVenue = !venueId || event?.validVenueIds.includes(venueId);
+    const keepRound = keepComplete && keepScheduled && validVenue && validDate;
+    if (!keepRound)
+      excludedRounds.push(round);
+    return keepRound;
+  }).sort(roundSort) || [];
+  return { ...SUCCESS, rounds, excludedRounds };
+}
+
 function addMatchUpScheduleItems(params) {
   const result = getDrawDefinition$1(params);
   if (result.error)
@@ -39107,13 +39140,14 @@ const competitionEngine = function() {
     const elapsed = Date.now() - start;
     const devContext = getDevContext();
     const log = { method: methodName };
-    const logErrors = typeof devContext.result === "object" && devContext.result.error;
-    if (![void 0, false].includes(devContext.perf) && (isNaN(devContext.perf) || elapsed > devContext.perf))
+    const logError = result.error && (devContext.errors === true || Array.isArray(devContext.errors) && devContext.errors.includes(methodName));
+    const exclude = Array.isArray(devContext.exclude) && devContext.exclude.includes(methodName);
+    if (!exclude && ![void 0, false].includes(devContext.perf) && (isNaN(devContext.perf) || elapsed > devContext.perf))
       log.elapsed = elapsed;
-    if (logErrors || devContext.params && !Array.isArray(devContext.params) || Array.isArray(devContext.params) && devContext.params?.includes(methodName)) {
+    if (!exclude && (logError || devContext.params && !Array.isArray(devContext.params) || Array.isArray(devContext.params) && devContext.params?.includes(methodName))) {
       log.params = params;
     }
-    if (logErrors || !logErrors && devContext.result && !Array.isArray(devContext.result) || Array.isArray(devContext.result) && devContext.result?.includes(methodName)) {
+    if (!exclude && (logError || devContext.result && !Array.isArray(devContext.result) || Array.isArray(devContext.result) && devContext.result?.includes(methodName))) {
       log.result = result;
     }
     if (Object.keys(log).length > 1)
@@ -42293,8 +42327,8 @@ function getAvoidanceConflicts({ isRoundRobin, groupedParticipants }) {
 function getSwapOptions({
   positionedParticipants,
   potentialDrawPositions,
-  avoidanceConflicts,
   drawPositionGroups,
+  avoidanceConflicts,
   isRoundRobin
 }) {
   return avoidanceConflicts.map((conflict) => {
@@ -53774,15 +53808,79 @@ function setTournamentStatus({ tournamentRecord, status }) {
 
 function addOnlineResource({
   tournamentRecord,
-  onlineResource
+  onlineResource,
+  organisationId,
+  participantId,
+  personId,
+  courtId,
+  venueId
 }) {
   if (!tournamentRecord)
     return { error: MISSING_TOURNAMENT_RECORD };
-  if (!onlineResource)
+  if (!isObject(onlineResource))
     return { error: MISSING_VALUE };
-  if (!tournamentRecord.onlineResources)
-    tournamentRecord.onlineResources = [];
-  tournamentRecord.onlineResources.push(onlineResource);
+  if (intersection(Object.keys(onlineResource), [
+    "resourceSubType",
+    "resourceType",
+    "identifier"
+  ]).length !== 3)
+    return decorateResult({
+      result: { error: INVALID_OBJECT },
+      context: { onlineResource }
+    });
+  if (organisationId) {
+    if (tournamentRecord.parentOrganisation?.parentOrganisationId !== organisationId) {
+      return decorateResult({ result: { error: NOT_FOUND } });
+    }
+    if (!tournamentRecord.parentOrganisation.onlineResources)
+      tournamentRecord.parentOrganisation.onlineResources = [];
+    tournamentRecord.parentOrganisation.onlineResources.push(onlineResource);
+  } else if (participantId || personId) {
+    const participant = (tournamentRecord.participants ?? []).find(
+      (p) => personId && p.person?.personId === personId || p.participantId === participantId
+    );
+    if (!participant) {
+      if (personId) {
+        return decorateResult({ result: { error: NOT_FOUND } });
+      } else {
+        return decorateResult({ result: { error: PARTICIPANT_NOT_FOUND } });
+      }
+    }
+    if (personId) {
+      if (participant.person?.personId !== personId) {
+        return decorateResult({ result: { error: INVALID_PARTICIPANT } });
+      }
+      if (!participant.person.onlineResources)
+        participant.person.onlineResources = [];
+      participant.person.onlineResources.push(onlineResource);
+    } else {
+      if (!participant.onlineResources)
+        participant.onlineResources = [];
+      participant.onlineResources.push(onlineResource);
+    }
+  } else if (courtId) {
+    const court = (tournamentRecord.venues ?? []).filter((v) => !venueId || v.venueId === venueId).flatMap(
+      (v) => (v.courts ?? []).filter((c) => c.courtId === courtId)
+    )?.[0];
+    if (!court)
+      return decorateResult({ result: { error: COURT_NOT_FOUND } });
+    if (!court.onlineResources)
+      court.onlineResources = [];
+    court.onlineResources.push(onlineResource);
+  } else if (venueId) {
+    const venue = (tournamentRecord.venues ?? []).find(
+      (v) => v.venueId === venueId
+    );
+    if (!venue)
+      return decorateResult({ result: { error: VENUE_NOT_FOUND } });
+    if (!venue.onlineResources)
+      venue.onlineResources = [];
+    venue.onlineResources.push(onlineResource);
+  } else {
+    if (!tournamentRecord.onlineResources)
+      tournamentRecord.onlineResources = [];
+    tournamentRecord.onlineResources.push(onlineResource);
+  }
   return { ...SUCCESS };
 }
 
@@ -59981,13 +60079,14 @@ const tournamentEngine = (() => {
     const elapsed = Date.now() - start;
     const devContext = getDevContext();
     const log = { method: methodName };
-    const logErrors = typeof devContext.result === "object" && devContext.result.error;
-    if (![void 0, false].includes(devContext.perf) && (isNaN(devContext.perf) || elapsed > devContext.perf))
+    const logError = result.error && (devContext.errors === true || Array.isArray(devContext.errors) && devContext.errors.includes(methodName));
+    const exclude = Array.isArray(devContext.exclude) && devContext.exclude.includes(methodName);
+    if (!exclude && ![void 0, false].includes(devContext.perf) && (isNaN(devContext.perf) || elapsed > devContext.perf))
       log.elapsed = elapsed;
-    if (logErrors || devContext.params && !Array.isArray(devContext.params) || Array.isArray(devContext.params) && devContext.params?.includes(methodName)) {
+    if (!exclude && (logError || devContext.params && !Array.isArray(devContext.params) || Array.isArray(devContext.params) && devContext.params?.includes(methodName))) {
       log.params = params;
     }
-    if (logErrors || !logErrors && devContext.result && !Array.isArray(devContext.result) || Array.isArray(devContext.result) && devContext.result?.includes(methodName)) {
+    if (!exclude && (logError || devContext.result && !Array.isArray(devContext.result) || Array.isArray(devContext.result) && devContext.result?.includes(methodName))) {
       log.result = result;
     }
     if (Object.keys(log).length > 1)