tods-competition-factory 2.3.0 → 2.3.2

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.3.0';
+    return '2.3.2';
 }
 
 const SINGLES_MATCHUP = 'SINGLES';
@@ -989,6 +989,14 @@ const COURT_EXISTS = {
     message: 'Court exists',
     code: 'ERR_EXISTING_COURT',
 };
+const BOOKING_NOT_FOUND = {
+    message: 'Booking not found',
+    code: 'ERR_NOT_FOUND_BOOKING',
+};
+const EXISTING_MATCHUPS = {
+    message: 'Existing matchUps conflict with booking',
+    code: 'ERR_EXISTING_MATCHUPS',
+};
 const VENUE_EXISTS = {
     message: 'Venue exists',
     code: 'ERR_EXISTING_VENUE',
@@ -1152,6 +1160,7 @@ const SCORES_PRESENT = {
 };
 const errorConditionConstants = {
     ANACHRONISM,
+    BOOKING_NOT_FOUND,
     CANNOT_CHANGE_WINNING_SIDE,
     CANNOT_MODIFY_TIEFORMAT,
     CANNOT_MODIFY_PARTICIPANT_TYPE,
@@ -1160,6 +1169,7 @@ const errorConditionConstants = {
     CATEGORY_MISMATCH,
     COURT_EXISTS,
     COURT_NOT_FOUND,
+    EXISTING_MATCHUPS,
     DRAW_DEFINITION_NOT_FOUND,
     DRAW_ID_EXISTS,
     DRAW_POSITION_ACTIVE,
@@ -2289,7 +2299,8 @@ function validTimeValue(value) {
     const spaceSplit = typeof value === 'string' ? value?.split(' ') : [];
     if (value && spaceSplit?.length > 1 && !['AM', 'PM'].includes(spaceSplit[1].toUpperCase()))
         return false;
-    return !!(!value || timeValidation.test(convertTime(value, true, true)));
+    const converted = convertTime(value, true, true);
+    return !!(!value || (converted && timeValidation.test(converted)));
 }
 function isValidDateString(scheduleDate) {
     return isISODateString(scheduleDate) || validDateString.test(scheduleDate);
@@ -2300,7 +2311,7 @@ function DateHHMM(date) {
     return HHMMSS(secs, { displaySeconds: false });
 }
 function HHMMSS(s, format) {
-    const secondNumber = parseInt(s, 10);
+    const secondNumber = Number.parseInt(s, 10);
     const hours = Math.floor(secondNumber / 3600);
     const minutes = Math.floor((secondNumber - hours * 3600) / 60);
     const seconds = secondNumber - hours * 3600 - minutes * 60;
@@ -2321,7 +2332,7 @@ function timeUTC(date) {
 function formatDate(date, separator = '-', format = 'YMD') {
     if (!date)
         return '';
-    if (typeof date === 'string' && date.indexOf('T') < 0)
+    if (typeof date === 'string' && !date.includes('T'))
         date = date + 'T00:00';
     const d = new Date(date);
     let month = '' + (d.getMonth() + 1);
@@ -2354,8 +2365,11 @@ function offsetTime(date) {
 function isDate(dateArg) {
     if (typeof dateArg == 'boolean')
         return false;
-    const t = (dateArg instanceof Date && dateArg) || (!isNaN(dateArg) && new Date(dateArg)) || false;
-    return t && !isNaN(t.valueOf());
+    const t = (dateArg instanceof Date && dateArg) || (!Number.isNaN(Number(dateArg)) && new Date(dateArg)) || false;
+    return t && !Number.isNaN(Number(t.valueOf()));
+}
+function isValidDateRange(minDate, maxDate) {
+    return minDate <= maxDate;
 }
 function generateDateRange(startDt, endDt) {
     if (!isValidDateString(startDt) || !isValidDateString(endDt))
@@ -2377,9 +2391,6 @@ function generateDateRange(startDt, endDt) {
         }
     }
     return between.map((date) => formatDate(date));
-    function isValidDateRange(minDate, maxDate) {
-        return minDate <= maxDate;
-    }
 }
 const re = /^([+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))([T\s]((([01]\d|2[0-3])((:?)[0-5]\d)?|24:?00)([.,]\d+(?!:))?)?(\17[0-5]\d([.,]\d+)?)?([zZ]|([+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)?$/;
 function isISODateString(dateString) {
@@ -2392,15 +2403,15 @@ function isTimeString(timeString) {
         return false;
     const noZ = timeString.split('Z')[0];
     const parts = noZ.split(':');
-    const isNumeric = parts.every((part) => !isNaN(parseInt(part)));
-    const invalid = parts.length < 2 || !isNumeric || parseInt(parts[0]) > 23 || parseInt(parts[1]) > 60;
+    const isNumeric = parts.every((part) => !Number.isNaN(Number.parseInt(part)));
+    const invalid = parts.length < 2 || !isNumeric || Number.parseInt(parts[0]) > 23 || Number.parseInt(parts[1]) > 60;
     return !invalid;
 }
 function timeStringMinutes$1(timeString) {
     const validTimeString = extractTime$1(timeString);
     if (!validTimeString)
         return 0;
-    const [hours, minutes] = validTimeString.split(':').map((value) => parseInt(value));
+    const [hours, minutes] = validTimeString.split(':').map((value) => Number.parseInt(value));
     return hours * 60 + minutes;
 }
 function dayMinutesToTimeString(totalMinutes) {
@@ -2419,7 +2430,7 @@ function extractTime$1(dateString) {
         : tidyTime(dateString);
 }
 function extractDate(dateString) {
-    return isISODateString(dateString) || dateValidation.test(dateString) ? dateString.split('T')[0] : undefined;
+    return isISODateString(dateString) || dateValidation.test(dateString) ? dateString.split('T')[0] : '';
 }
 function dateStringDaysChange(dateString, daysChange) {
     const date = new Date(dateString);
@@ -2427,20 +2438,22 @@ function dateStringDaysChange(dateString, daysChange) {
     return extractDate(date.toISOString());
 }
 function splitTime(value) {
-    value = typeof value !== 'string' ? '00:00' : value;
+    value = typeof value === 'string' ? value : '00:00';
     const o = {}, time = {};
     ({ 0: o.time, 1: o.ampm } = value.split(' ') || []);
     ({ 0: time.hours, 1: time.minutes } = o.time.split(':') || []);
     time.ampm = o.ampm;
-    if (isNaN(time.hours) || isNaN(time.minutes) || (time.ampm && !['AM', 'PM'].includes(time.ampm.toUpperCase())))
+    if (Number.isNaN(Number.parseInt(time.hours)) ||
+        Number.isNaN(Number.parseInt(time.minutes)) ||
+        (time.ampm && !['AM', 'PM'].includes(time.ampm.toUpperCase())))
         return {};
     return time;
 }
 function militaryTime(value) {
     const time = splitTime(value);
     if (time.ampm && time.hours) {
-        if (time.ampm.toLowerCase() === 'pm' && parseInt(time.hours) < 12)
-            time.hours = ((time.hours && parseInt(time.hours)) || 0) + 12;
+        if (time.ampm.toLowerCase() === 'pm' && Number.parseInt(time.hours) < 12)
+            time.hours = ((time.hours && Number.parseInt(time.hours)) || 0) + 12;
         if (time.ampm.toLowerCase() === 'am' && time.hours === '12')
             time.hours = '00';
     }
@@ -2476,21 +2489,21 @@ function convertTime(value, time24, keepDate) {
     const hasDate = extractDate(value);
     const timeString = extractTime$1(value);
     const timeValue = hasDate ? timeString : value;
-    return !value
-        ? undefined
-        : (time24 && ((hasDate && keepDate && value) || militaryTime(timeValue))) || regularTime(timeValue);
+    return value
+        ? (time24 && ((hasDate && keepDate && value) || militaryTime(timeValue))) || regularTime(timeValue)
+        : undefined;
 }
 function timeSort(a, b) {
     const as = splitTime(a);
     const bs = splitTime(b);
-    if (parseInt(as.hours) < parseInt(bs.hours))
+    if (Number.parseInt(as.hours) < Number.parseInt(bs.hours))
         return -1;
-    if (parseInt(as.hours) > parseInt(bs.hours))
+    if (Number.parseInt(as.hours) > Number.parseInt(bs.hours))
         return 1;
     if (as.hours === bs.hours) {
-        if (parseInt(as.minutes) < parseInt(bs.minutes))
+        if (Number.parseInt(as.minutes) < Number.parseInt(bs.minutes))
             return -1;
-        if (parseInt(as.minutes) > parseInt(bs.minutes))
+        if (Number.parseInt(as.minutes) > Number.parseInt(bs.minutes))
             return 1;
     }
     return 0;
@@ -2529,8 +2542,8 @@ function addMinutesToTimeString(timeString, minutes) {
     const validTimeString = extractTime$1(timeString);
     if (!validTimeString)
         return '00:00';
-    const minutesToAdd = isNaN(minutes) ? 0 : minutes;
-    return extractTime$1(addMinutes(timeToDate(validTimeString), minutesToAdd).toISOString());
+    const minutesToAdd = Number.isNaN(minutes) ? 0 : minutes;
+    return extractTime$1(addMinutes(timeToDate(validTimeString), minutesToAdd).toISOString()) || '00:00';
 }
 function addMinutes(startDate, minutes) {
     const date = new Date(startDate);
@@ -2586,23 +2599,27 @@ function getCategoryAgeDetails(params) {
     if (!isValidCategory)
         return { error: INVALID_CATEGORY };
     const consideredDate = params.consideredDate ?? extractDate(new Date().toLocaleDateString('sv'));
-    if (!isValidDateString(consideredDate))
+    if (!consideredDate || !isValidDateString(consideredDate))
         return { error: INVALID_DATE };
     const [consideredYear] = consideredDate
         .split('-')
         .slice(0, 3)
-        .map((n) => parseInt(n));
+        .map((n) => Number.parseInt(n));
     const previousDayDate = dateStringDaysChange(consideredDate, -1);
+    if (!previousDayDate)
+        return { error: INVALID_DATE };
     const [previousDayMonth, previousDay] = previousDayDate
         .split('-')
         .slice(1, 3)
-        .map((n) => parseInt(n));
+        .map((n) => Number.parseInt(n));
     const previousMonthDay = `${zeroPad(previousDayMonth)}-${zeroPad(previousDay)}`;
     const nextDayDate = dateStringDaysChange(consideredDate, 1);
+    if (!nextDayDate)
+        return { error: INVALID_DATE };
     const [nextDayMonth, nextDay] = nextDayDate
         .split('-')
         .slice(1, 3)
-        .map((n) => parseInt(n));
+        .map((n) => Number.parseInt(n));
     const nextMonthDay = `${zeroPad(nextDayMonth)}-${zeroPad(nextDay)}`;
     let calculatedAgeMaxDate = ageMin && dateStringDaysChange(consideredDate, -1 * 365 * ageMin);
     let calculatedAgeMinDate = ageMax && dateStringDaysChange(consideredDate, -1 * 365 * ageMax);
@@ -2679,7 +2696,7 @@ function getCategoryAgeDetails(params) {
     };
     const processCode = (code) => {
         const [pre, age, post] = (code.match(prePost) || []).slice(1);
-        const ageInt = parseInt(age);
+        const ageInt = Number.parseInt(age);
         if (pre === 'U') {
             if (category.ageMaxDate && category.ageMaxDate !== ageMaxDate) {
                 addError(`Invalid submitted ageMaxDate: ${category.ageMaxDate}`);
@@ -2698,8 +2715,8 @@ function getCategoryAgeDetails(params) {
         else if (post === 'O') {
             oPost(ageInt);
         }
-        ageMaxDate = ageMaxDate ?? calculatedAgeMaxDate;
-        ageMinDate = ageMinDate ?? calculatedAgeMinDate;
+        ageMaxDate = (ageMaxDate ?? calculatedAgeMaxDate) || undefined;
+        ageMinDate = (ageMinDate ?? calculatedAgeMinDate) || undefined;
     };
     if (isCombined) {
         ageMaxDate = undefined;
@@ -2714,7 +2731,7 @@ function getCategoryAgeDetails(params) {
             const ageMinYear = consideredYear - category.ageMax - 1;
             ageMinDate = constructedDate(ageMinYear, nextMonthDay);
         }
-        const [lowAge, highAge] = (ageCategoryCode?.match(extractCombined) ?? []).slice(1).map((n) => parseInt(n));
+        const [lowAge, highAge] = (ageCategoryCode?.match(extractCombined) ?? []).slice(1).map((n) => Number.parseInt(n));
         if (lowAge <= highAge) {
             ageMin = lowAge;
             ageMax = highAge;
@@ -8675,7 +8692,7 @@ function getRoundMatchUps({ matchUps = [], interpolate }) {
     if (interpolate) {
         const maxRoundNumber = Math.max(...Object.keys(roundMatchUps)
             .map((key) => ensureInt(key))
-            .filter((f) => !isNaN(f)));
+            .filter((f) => !Number.isNaN(f)));
         const maxRoundMatchUpsCount = roundMatchUps[maxRoundNumber]?.length;
         if (maxRoundMatchUpsCount > 1 && isPowerOf2(maxRoundMatchUpsCount)) {
             const nextRound = maxRoundNumber + 1;
@@ -8698,10 +8715,10 @@ function getRoundMatchUps({ matchUps = [], interpolate }) {
     let feedRoundIndex = 0;
     const roundNumbers = Object.keys(roundMatchUps)
         .map((key) => ensureInt(key))
-        .filter((f) => !isNaN(f));
+        .filter((f) => !Number.isNaN(f));
     roundNumbers.forEach((roundNumber) => {
         const currentRoundMatchUps = roundMatchUps[roundNumber].sort((a, b) => a.roundPosition - b.roundPosition);
-        const currentRoundDrawPositions = currentRoundMatchUps.map((matchUp) => matchUp?.drawPositions || []).flat();
+        const currentRoundDrawPositions = currentRoundMatchUps.flatMap((matchUp) => matchUp?.drawPositions || []);
         roundProfile[roundNumber].roundNumber = roundNumber;
         roundProfile[roundNumber].roundFactor = roundProfile[roundNumber].matchUpsCount
             ? maxMatchUpsCount / roundProfile[roundNumber].matchUpsCount
@@ -8762,7 +8779,7 @@ function getRoundMatchUps({ matchUps = [], interpolate }) {
             roundIndex += 1;
         }
     });
-    const roundsNotPowerOf2 = !!Object.values(roundProfile).find(({ matchUpsCount }) => !isPowerOf2(matchUpsCount));
+    const roundsNotPowerOf2 = !!Object.values(roundProfile).some(({ matchUpsCount }) => !isPowerOf2(matchUpsCount));
     const hasNoRoundPositions = matchUps.some((matchUp) => !matchUp.roundPosition);
     return {
         hasNoRoundPositions,
@@ -9115,7 +9132,7 @@ function getRoundContextProfile({ roundNamingPolicy, drawDefinition, structure,
 const add = (a, b) => (a || 0) + (b || 0);
 function getBand(spread, bandProfiles) {
     const spreadValue = Array.isArray(spread) ? spread[0] : spread;
-    return ((isNaN(spreadValue) && WALKOVER$1) ||
+    return ((Number.isNaN(spreadValue) && WALKOVER$1) ||
         (spreadValue <= bandProfiles[DECISIVE] && DECISIVE) ||
         (spreadValue <= bandProfiles[ROUTINE] && ROUTINE) ||
         COMPETITIVE);
@@ -9285,7 +9302,7 @@ function getCheckedInParticipantIds({ matchUp }) {
         return { error: MISSING_MATCHUP };
     if (!matchUp.hasContext)
         return { error: MISSING_CONTEXT };
-    if (!matchUp.sides || matchUp.sides.filter(Boolean).length !== 2) {
+    if (!matchUp.sides || matchUp?.sides.filter(Boolean).length !== 2) {
         return { error: INVALID_MATCHUP };
     }
     const { nestedIndividualParticipantIds, allRelevantParticipantIds, sideParticipantIds } = getMatchUpParticipantIds({
@@ -15782,6 +15799,84 @@ function addVoluntaryConsolationStructure({ structureName = constantToString(VOL
     return { ...SUCCESS };
 }
 
+function getDivisions({ size }) {
+    const divisions = [size];
+    let division = size;
+    while (division / 2 === Math.floor(division / 2)) {
+        division = division / 2;
+        divisions.push(division);
+    }
+    if (!divisions.includes(1))
+        divisions.push(1);
+    divisions.sort(numericSort);
+    divisions.reverse();
+    return divisions;
+}
+function getSubBlock({ blockPattern, index }) {
+    let i = 0;
+    for (const subBlock of blockPattern) {
+        if (i === index)
+            return subBlock;
+        let j = 0;
+        while (j < subBlock.length) {
+            if (i === index)
+                return subBlock;
+            i += 1;
+            j++;
+        }
+    }
+}
+function generateBlockPattern({ positioning, size }) {
+    const divisions = getDivisions({ size });
+    const divisionGroupings = [];
+    const selected = [];
+    const firstMember = (arr) => arr[0];
+    const lastMember = (arr) => arr[arr.length - 1];
+    const getMember = (arr, i) => (positioning && [CLUSTER, ADJACENT, WATERFALL].includes(positioning) && i % 2
+        ? lastMember(arr)
+        : firstMember(arr)) || firstMember(arr);
+    const noneSelected = (chunk, i) => {
+        if (chunk.every((member) => !selected.includes(member))) {
+            const member = getMember(chunk, i);
+            selected.push(member);
+            return member;
+        }
+    };
+    const notSelected = (chunk) => {
+        const notSelected = chunk.filter((member) => !selected.includes(member));
+        if (notSelected.length) {
+            selected.push(...notSelected);
+            return notSelected;
+        }
+    };
+    const select = (chunk, i) => {
+        const member = getMember(chunk, i);
+        if (!selected.includes(member)) {
+            selected.push(member);
+            return member;
+        }
+    };
+    const range = generateRange(1, size + 1);
+    for (const division of divisions) {
+        if (division === 1) {
+            const chunks = chunkArray(range, 2);
+            const positions = chunks.map(noneSelected).filter(Boolean);
+            if (positions.length)
+                divisionGroupings.push(positions);
+            const lastPositions = chunks.flatMap(notSelected).filter(Boolean);
+            if (lastPositions.length)
+                divisionGroupings.push(lastPositions);
+        }
+        else {
+            const chunks = chunkArray(range, division);
+            const positions = chunks.map(select).filter(Boolean);
+            if (positions.length)
+                divisionGroupings.push(positions);
+        }
+    }
+    return { divisions, divisionGroupings };
+}
+
 function getRoundRobinGroupMatchUps({ drawPositions }) {
     if (!drawPositions?.length)
         return { error: MISSING_DRAW_POSITIONS };
@@ -16132,84 +16227,6 @@ function getNumericSeedValue(seedValue) {
     return Infinity;
 }
 
-function getDivisions({ size }) {
-    const divisions = [size];
-    let division = size;
-    while (division / 2 === Math.floor(division / 2)) {
-        division = division / 2;
-        divisions.push(division);
-    }
-    if (!divisions.includes(1))
-        divisions.push(1);
-    divisions.sort(numericSort);
-    divisions.reverse();
-    return divisions;
-}
-function getSubBlock({ blockPattern, index }) {
-    let i = 0;
-    for (const subBlock of blockPattern) {
-        if (i === index)
-            return subBlock;
-        let j = 0;
-        while (j < subBlock.length) {
-            if (i === index)
-                return subBlock;
-            i += 1;
-            j++;
-        }
-    }
-}
-function generateBlockPattern({ positioning, size }) {
-    const divisions = getDivisions({ size });
-    const divisionGroupings = [];
-    const selected = [];
-    const firstMember = (arr) => arr[0];
-    const lastMember = (arr) => arr[arr.length - 1];
-    const getMember = (arr, i) => (positioning && [CLUSTER, ADJACENT, WATERFALL].includes(positioning) && i % 2
-        ? lastMember(arr)
-        : firstMember(arr)) || firstMember(arr);
-    const noneSelected = (chunk, i) => {
-        if (chunk.every((member) => !selected.includes(member))) {
-            const member = getMember(chunk, i);
-            selected.push(member);
-            return member;
-        }
-    };
-    const notSelected = (chunk) => {
-        const notSelected = chunk.filter((member) => !selected.includes(member));
-        if (notSelected.length) {
-            selected.push(...notSelected);
-            return notSelected;
-        }
-    };
-    const select = (chunk, i) => {
-        const member = getMember(chunk, i);
-        if (!selected.includes(member)) {
-            selected.push(member);
-            return member;
-        }
-    };
-    const range = generateRange(1, size + 1);
-    for (const division of divisions) {
-        if (division === 1) {
-            const chunks = chunkArray(range, 2);
-            const positions = chunks.map(noneSelected).filter(Boolean);
-            if (positions.length)
-                divisionGroupings.push(positions);
-            const lastPositions = chunks.flatMap(notSelected).filter(Boolean);
-            if (lastPositions.length)
-                divisionGroupings.push(lastPositions);
-        }
-        else {
-            const chunks = chunkArray(range, division);
-            const positions = chunks.map(select).filter(Boolean);
-            if (positions.length)
-                divisionGroupings.push(positions);
-        }
-    }
-    return { divisions, divisionGroupings };
-}
-
 function getValidSeedBlocks({ provisionalPositioning, returnAllProxies, appliedPolicies, seedingProfile, drawDefinition, allPositions, structure, }) {
     let validSeedBlocks = [];
     if (!structure)
@@ -16399,7 +16416,7 @@ function constructPower2Blocks(params) {
     let count = 1;
     const blocks = [];
     const { seedBlocks } = getSeedBlocks({
-        cluster: getSeedPattern(seedingProfile) === CLUSTER,
+        cluster: [CLUSTER, ADJACENT].includes(getSeedPattern(seedingProfile)),
         participantsCount: baseDrawSize,
         roundRobinGroupsCount,
     });
@@ -18855,7 +18872,7 @@ function getUnseededByePositions({ provisionalPositioning, seedOrderByePositions
     if (isFeedIn) {
         const baseDrawSize = relevantDrawPositions.length;
         const { seedBlocks } = getSeedBlocks({
-            cluster: getSeedPattern(seedingProfile) === CLUSTER,
+            cluster: [CLUSTER, ADJACENT].includes(getSeedPattern(seedingProfile)),
             participantsCount: baseDrawSize,
         });
         const blockDrawPositions = seedBlocks.map((seedBlock) => seedBlock.map((drawPosition) => drawPosition + drawPositionOffset));
@@ -21671,8 +21688,7 @@ function processPlayoffGroups({ requireSequential = true, playoffMatchUpFormat,
                 finishingPositions,
                 sourceStructureId,
             });
-            links.push(playoffLink);
-            links.push(...playoffLinks);
+            links.push(playoffLink, ...playoffLinks);
             structures.push(...playoffStructures);
             finishingPositionTargets.push({
                 structureId: playoffStructure.structureId,
@@ -21799,8 +21815,7 @@ function processPlayoffGroups({ requireSequential = true, playoffMatchUpFormat,
                 finishingPositions,
                 sourceStructureId,
             });
-            links.push(playoffLink);
-            links.push(...feedInLinks);
+            links.push(playoffLink, ...feedInLinks);
             structures.push(...champitionShipStructures);
             finishingPositionTargets.push({
                 structureId: playoffStructure.structureId,
@@ -22015,7 +22030,7 @@ function getRatingConvertedFromELO({ targetRatingType, sourceRating }) {
         sourceRange: eloRatingRange,
         value: sourceRating,
     });
-    const convertedRating = parseFloat(result.toFixed(decimalPlaces));
+    const convertedRating = Number.parseFloat(result.toFixed(decimalPlaces));
     return invertedScale ? maxTargetRatingRange - convertedRating : convertedRating;
 }
 
@@ -22066,8 +22081,8 @@ function calculatePressureRatings({ participantResults, sides, score }) {
     }
 }
 function getSideValues$1({ side1ConvertedRating, side2ConvertedRating, score }) {
-    const highRating = side1ConvertedRating > side2ConvertedRating ? side1ConvertedRating : side2ConvertedRating;
-    const lowRating = side1ConvertedRating > side2ConvertedRating ? side2ConvertedRating : side1ConvertedRating;
+    const highRating = Math.max(side1ConvertedRating, side2ConvertedRating);
+    const lowRating = Math.min(side1ConvertedRating, side2ConvertedRating);
     const ratingsDifference = Math.abs(side1ConvertedRating - side2ConvertedRating);
     const eloRatingRange = ratingsParameters[ELO].range;
     const rangeMax = Math.max(...eloRatingRange);
@@ -22232,19 +22247,19 @@ function calculatePercentages({ participantResults, groupingTotal, matchUpFormat
             ? totalSets
             : perPlayer * (bracketSetsToWin) || setsWon + setsLost;
         let setsPct = Math.round((setsWon / setsTotal) * precision) / precision;
-        if (setsPct === Infinity || isNaN(setsPct))
+        if (setsPct === Infinity || Number.isNaN(setsPct))
             setsPct = setsTotal;
         const tieMatchUpsWon = participantResults[participantId].tieMatchUpsWon;
         const tieMatchUpsLost = participantResults[participantId].tieMatchUpsLost;
         const tieMatchUpsTotal = tieMatchUpsWon + tieMatchUpsLost;
         let tieMatchUpsPct = Math.round((tieMatchUpsWon / tieMatchUpsTotal) * precision) / precision;
-        if (tieMatchUpsPct === Infinity || isNaN(tieMatchUpsPct))
+        if (tieMatchUpsPct === Infinity || Number.isNaN(tieMatchUpsPct))
             tieMatchUpsPct = tieMatchUpsWon;
         const matchUpsWon = participantResults[participantId].matchUpsWon;
         const matchUpsLost = participantResults[participantId].matchUpsLost;
         const matchUpsTotal = matchUpsWon + matchUpsLost;
         let matchUpsPct = Math.round((matchUpsWon / matchUpsTotal) * precision) / precision;
-        if (matchUpsPct === Infinity || isNaN(matchUpsPct))
+        if (matchUpsPct === Infinity || Number.isNaN(matchUpsPct))
             matchUpsPct = matchUpsWon;
         const gamesWon = participantResults[participantId].gamesWon || 0;
         const gamesLost = participantResults[participantId].gamesLost || 0;
@@ -22253,11 +22268,11 @@ function calculatePercentages({ participantResults, groupingTotal, matchUpFormat
             ? totalGames
             : Math.max(minimumExpectedGames, gamesWon + gamesLost);
         let gamesPct = Math.round((gamesWon / gamesTotal) * precision) / precision;
-        if (gamesPct === Infinity || isNaN(gamesPct))
+        if (gamesPct === Infinity || Number.isNaN(gamesPct))
             gamesPct = 0;
         const pointsTotal = participantResults[participantId].pointsWon + participantResults[participantId].pointsLost;
         let pointsPct = Math.round((participantResults[participantId].pointsWon / pointsTotal) * precision) / precision;
-        if (pointsPct === Infinity || isNaN(pointsPct))
+        if (pointsPct === Infinity || Number.isNaN(pointsPct))
             pointsPct = 0;
         participantResults[participantId].setsWon = setsWon;
         participantResults[participantId].setsLost = setsLost;
@@ -23476,16 +23491,16 @@ function evaluateCollectionResult({ collectionDefinition, groupValueNumbers, gro
     else {
         sideCollectionValues = sideMatchUpValues;
     }
-    if (!belongsToValueGroup) {
-        sideCollectionValues.forEach((sideCollectionValue, i) => (sideTieValues[i] += sideCollectionValue || 0));
-    }
-    else {
+    if (belongsToValueGroup) {
         groupValueGroups[collectionGroupNumber].sideWins[0] += sideWins[0] || 0;
         groupValueGroups[collectionGroupNumber].sideWins[1] += sideWins[1] || 0;
         groupValueGroups[collectionGroupNumber].allGroupMatchUpsCompleted =
             groupValueGroups[collectionGroupNumber].allGroupMatchUpsCompleted && allCollectionMatchUpsCompleted;
         groupValueGroups[collectionGroupNumber].matchUpsCount += collectionMatchUps.length;
     }
+    else {
+        sideCollectionValues.forEach((sideCollectionValue, i) => (sideTieValues[i] += sideCollectionValue || 0));
+    }
 }
 function getCollectionPositionValue({ collectionDefinition, collectionPosition }) {
     const collectionValueProfiles = collectionDefinition.collectionValueProfiles || [];
@@ -23497,7 +23512,7 @@ function generateTieMatchUpScore(params) {
     const { sideAdjustments = [0, 0], separator = '-', drawDefinition, matchUpsMap, structure, matchUp, event, } = params;
     if (!Array.isArray(sideAdjustments) ||
         sideAdjustments.length !== 2 ||
-        isNaN(sideAdjustments.reduce((a, b) => a + b))) {
+        Number.isNaN(sideAdjustments.reduce((a, b) => a + b))) {
         return { error: INVALID_VALUES };
     }
     if (!matchUp)
@@ -24902,7 +24917,7 @@ function analyzeDraws({ tournamentRecord }) {
     };
     const eventsMap = {};
     const eventDraws = tournamentRecord.events
-        ?.map((event) => {
+        ?.flatMap((event) => {
         const eventId = event.eventId;
         eventsMap[eventId] = event;
         return (event?.drawDefinitions || []).map((drawDefinition) => ({
@@ -24910,7 +24925,6 @@ function analyzeDraws({ tournamentRecord }) {
             eventId,
         }));
     })
-        .flat()
         .filter(Boolean);
     eventDraws.forEach(({ drawDefinition, eventId }) => {
         let positionsAssignedCount = 0;
@@ -24944,11 +24958,11 @@ function analyzeDraws({ tournamentRecord }) {
             const activeRounds = roundProfile &&
                 Object.keys(roundProfile)
                     .filter((roundNumber) => !roundProfile[roundNumber].inactiveRound)
-                    .map((roundNumber) => parseInt(roundNumber));
+                    .map((roundNumber) => Number.parseInt(roundNumber));
             const inactiveRounds = roundProfile &&
                 Object.keys(roundProfile)
                     .filter((roundNumber) => roundProfile[roundNumber].inactiveRound)
-                    .map((roundNumber) => parseInt(roundNumber));
+                    .map((roundNumber) => Number.parseInt(roundNumber));
             const inactiveStructure = roundProfile && Object.values(roundProfile).every((profile) => profile.inactiveRound);
             return {
                 positionsAssignedCount: positionsAssigned?.length ?? 0,
@@ -28379,7 +28393,7 @@ const k538 = (countables = 0) => 250 / Math.pow(countables + 5, 0.4);
 const kDefault = () => 1;
 function kSet(maxCountables = 3, counted = 2) {
     const kset = maxCountables / counted;
-    return isNaN(kset) ? eloConfig.kDefault() : kset;
+    return Number.isNaN(kset) ? eloConfig.kDefault() : kset;
 }
 const eloConfig = {
     nSpread: 400,
@@ -28400,7 +28414,7 @@ function calculateNewRatings(params) {
     const invertedScale = ratingRange[0] > ratingRange[1];
     const decimalPlaces = ratingParameters.decimalsCount || 0;
     const consideredRange = invertedScale ? ratingRange.slice().reverse() : ratingRange;
-    const inRange = (range, value) => parseFloat(value) >= Math.min(...range) && parseFloat(value) <= Math.max(...range);
+    const inRange = (range, value) => Number.parseFloat(value) >= Math.min(...range) && Number.parseFloat(value) <= Math.max(...range);
     if (!inRange(ratingRange, winnerRating) || !inRange(ratingRange, loserRating)) {
         if (!inRange(ratingRange, winnerRating))
             winnerRating = ratingParameters.defaultInitialization;
@@ -28438,9 +28452,9 @@ function calculateNewRatings(params) {
     const updatedWinnerRating = invertedScale
         ? ratingRange[0] - convertedUpdatedWinnerRating
         : convertedUpdatedWinnerRating;
-    let newWinnerRating = parseFloat(updatedWinnerRating.toFixed(decimalPlaces));
+    let newWinnerRating = Number.parseFloat(updatedWinnerRating.toFixed(decimalPlaces));
     const updatedLoserRating = invertedScale ? ratingRange[0] - convertedUpdatedLoserRating : convertedUpdatedLoserRating;
-    let newLoserRating = parseFloat(updatedLoserRating.toFixed(decimalPlaces));
+    let newLoserRating = Number.parseFloat(updatedLoserRating.toFixed(decimalPlaces));
     const percentageDifference = Math.max(...ratingRange)
         ? Math.abs(winnerRating - loserRating) / Math.max(...ratingRange)
         : 0;
@@ -30447,7 +30461,7 @@ function keyValueScore(params) {
         const { tiebreakTo, NoAD } = tiebreakFormat || {};
         const leadingSide = getLeadingSide({ set });
         if (!analysis.isTiebreakSet) {
-            const lowTiebreakScore = parseInt(scoreString.split(open).reverse()[0]);
+            const lowTiebreakScore = Number.parseInt(scoreString.split(open).reverse()[0]);
             const highTiebreakScore = getHighTiebreakValue$1({
                 lowValue: lowTiebreakScore,
                 tiebreakTo,
@@ -34591,11 +34605,13 @@ function getCompetitionDateRange({ tournamentRecords }) {
     const dateRange = tournamentIds.reduce((dateRange, tournamentId) => {
         const tournamentRecord = tournamentRecords[tournamentId];
         const { tournamentInfo: { startDate, endDate }, } = getTournamentInfo({ tournamentRecord });
-        const dateOfStart = startDate && new Date(extractDate(startDate));
+        const extractedStart = startDate && extractDate(startDate);
+        const dateOfStart = extractedStart && new Date(extractedStart);
         if (!dateRange.startDate || (dateOfStart && dateOfStart < dateRange.startDate)) {
             dateRange.startDate = dateOfStart;
         }
-        const dateOfEnd = endDate && new Date(extractDate(endDate));
+        const extractedEnd = endDate && extractDate(endDate);
+        const dateOfEnd = extractedEnd && new Date(extractedEnd);
         if (!dateRange.endDate || (dateOfEnd && dateOfEnd > dateRange.endDate)) {
             dateRange.endDate = dateOfEnd;
         }
@@ -36675,7 +36691,31 @@ function getProfileRounds({ tournamentRecords, schedulingProfile, tournamentReco
     return { profileRounds, segmentedRounds };
 }
 
-function courtGridRows({ courtPrefix = 'C|', minRowsCount, courtsData }) {
+function getCourtDateAvailability({ court, date }) {
+    const targetDateAvailability = date && court.dateAvailability.find((availability) => sameDay(availability.date, date));
+    const defaultAvailability = court.dateAvailability.find((availability) => !availability.date);
+    return targetDateAvailability || defaultAvailability;
+}
+
+function getGridBookings({ court, date }) {
+    const courtDate = getCourtDateAvailability({ court, date });
+    const gridBookings = new Map();
+    const timeBookings = [];
+    (courtDate?.bookings || []).forEach((booking) => {
+        if (typeof booking.courtOrder === 'number') {
+            const rowCount = booking.rowCount || 1;
+            for (let i = 0; i < rowCount; i++) {
+                gridBookings.set(booking.courtOrder + i, booking);
+            }
+        }
+        else {
+            timeBookings.push(booking);
+        }
+    });
+    return { gridBookings, timeBookings };
+}
+
+function courtGridRows({ courtPrefix = 'C|', minRowsCount, courtsData, scheduledDate }) {
     if (!Array.isArray(courtsData))
         return { error: INVALID_VALUES };
     const maxCourtOrder = courtsData?.reduce((order, court) => {
@@ -36687,7 +36727,21 @@ function courtGridRows({ courtPrefix = 'C|', minRowsCount, courtsData }) {
     const rowBuilder = generateRange(0, rowsCount).map((rowIndex) => ({
         matchUps: generateRange(0, courtsData.length).map((courtIndex) => {
             const courtInfo = courtsData[courtIndex];
-            const { courtId, venueId } = courtInfo;
+            const { courtId, venueId, court } = courtInfo;
+            if (scheduledDate && court) {
+                const { gridBookings } = getGridBookings({
+                    court,
+                    date: scheduledDate,
+                });
+                if (gridBookings.has(rowIndex + 1)) {
+                    const booking = gridBookings.get(rowIndex + 1);
+                    return {
+                        schedule: { courtOrder: rowIndex + 1, venueId, courtId },
+                        isBlocked: true,
+                        booking,
+                    };
+                }
+            }
             return {
                 schedule: {
                     courtOrder: rowIndex + 1,
@@ -37557,8 +37611,10 @@ function competitionScheduleMatchUps(params) {
         venues,
     };
     if (withCourtGridRows) {
+        const scheduledDate = params.matchUpFilters?.scheduledDate;
         const { rows, courtPrefix } = courtGridRows({
             minRowsCount: Math.max(minCourtGridRows || 0, dateMatchUps.length || 0),
+            scheduledDate,
             courtsData,
         });
         result.courtPrefix = courtPrefix;
@@ -38497,7 +38553,7 @@ function getEvents({ tournamentRecord, withScaleValues, scaleEventType, inContex
             withScaleValues: true,
             tournamentRecord,
         }).participantMap;
-        const sum = (values) => values.reduce((total, value) => total + parseFloat(value), 0);
+        const sum = (values) => values.reduce((total, value) => total + Number.parseFloat(value), 0);
         for (const event of eventCopies) {
             const eventType = scaleEventType ?? event.eventType;
             const eventId = event.eventId;
@@ -38518,7 +38574,7 @@ function getEvents({ tournamentRecord, withScaleValues, scaleEventType, inContex
                             eventsMap[eventId].ratings[scaleName] = [];
                         const accessor = ratingsParameters[scaleName]?.accessor;
                         if (accessor) {
-                            const value = parseFloat(rating.scaleValue?.[accessor]);
+                            const value = Number.parseFloat(rating.scaleValue?.[accessor]);
                             if (value)
                                 eventsMap[eventId].ratings[scaleName].push(value);
                         }
@@ -38536,15 +38592,15 @@ function getEvents({ tournamentRecord, withScaleValues, scaleEventType, inContex
             };
             for (const participantId of participantIds) {
                 const participant = participantMap?.[participantId]?.participant;
-                if (participant?.participantType !== INDIVIDUAL) {
+                if (participant?.participantType === INDIVIDUAL) {
+                    processParticipant(participant);
+                }
+                else {
                     for (const individualParticipantId of participant?.individualParticipantIds ?? []) {
                         const individualParticipant = participantMap?.[individualParticipantId]?.participant;
                         processParticipant(individualParticipant);
                     }
                 }
-                else {
-                    processParticipant(participant);
-                }
             }
             const ratings = eventsMap[eventId].ratings;
             for (const scaleName of Object.keys(ratings)) {
@@ -38553,8 +38609,8 @@ function getEvents({ tournamentRecord, withScaleValues, scaleEventType, inContex
                     continue;
                 const med = median(scaleRating)?.toFixed(2);
                 eventsMap[eventId].ratingsStats[scaleName] = {
-                    avg: parseFloat((sum(scaleRating) / scaleRating.length).toFixed(2)),
-                    median: med ? parseFloat(med) : undefined,
+                    avg: Number.parseFloat((sum(scaleRating) / scaleRating.length).toFixed(2)),
+                    median: med ? Number.parseFloat(med) : undefined,
                     max: Math.max(...scaleRating),
                     min: Math.min(...scaleRating),
                 };
@@ -38568,7 +38624,7 @@ function getEvents({ tournamentRecord, withScaleValues, scaleEventType, inContex
                                 eventsMap[eventId].draws[drawId].ratings[scaleName] = [];
                             const accessor = ratingsParameters[scaleName]?.accessor;
                             if (accessor) {
-                                const value = parseFloat(rating.scaleValue?.[accessor]);
+                                const value = Number.parseFloat(rating.scaleValue?.[accessor]);
                                 if (value) {
                                     eventsMap[eventId].draws[drawId].ratings[scaleName].push(value);
                                 }
@@ -38589,15 +38645,15 @@ function getEvents({ tournamentRecord, withScaleValues, scaleEventType, inContex
                 };
                 for (const participantId of participantIds.filter(Boolean)) {
                     const participant = participantMap?.[participantId]?.participant;
-                    if (participant?.participantType !== INDIVIDUAL) {
+                    if (participant?.participantType === INDIVIDUAL) {
+                        processParticipant(participant);
+                    }
+                    else {
                         for (const individualParticipantId of participant?.individualParticipantIds ?? []) {
                             const individualParticipant = participantMap?.[individualParticipantId]?.participant;
                             processParticipant(individualParticipant);
                         }
                     }
-                    else {
-                        processParticipant(participant);
-                    }
                 }
             };
             const processedDrawIds = [];
@@ -38634,8 +38690,8 @@ function getEvents({ tournamentRecord, withScaleValues, scaleEventType, inContex
                         continue;
                     const med = median(scaleRating)?.toFixed(2);
                     eventsMap[eventId].draws[drawId].ratingsStats[scaleName] = {
-                        avg: parseFloat((sum(scaleRating) / scaleRating.length).toFixed(2)),
-                        median: med ? parseFloat(med) : undefined,
+                        avg: Number.parseFloat((sum(scaleRating) / scaleRating.length).toFixed(2)),
+                        median: med ? Number.parseFloat(med) : undefined,
                         max: Math.max(...scaleRating),
                         min: Math.min(...scaleRating),
                     };
@@ -42085,12 +42141,6 @@ function generateCourts(params) {
     return { ...SUCCESS, courts };
 }
 
-function getCourtDateAvailability({ court, date }) {
-    const targetDateAvailability = date && court.dateAvailability.find((availability) => sameDay(availability.date, date));
-    const defaultAvailability = court.dateAvailability.find((availability) => !availability.date);
-    return targetDateAvailability || defaultAvailability;
-}
-
 function generateTimeSlots(params) {
     const paramsCheck = checkRequiredParameters(params, [{ courtDate: true, _ofType: OBJECT }]);
     if (paramsCheck.error)
@@ -42100,7 +42150,7 @@ function generateTimeSlots(params) {
     let startTime = timeToDate(courtDate.startTime);
     (courtDate.bookings || [])
         .filter((booking) => !booking.bookingType || !includeBookingTypes.includes(booking.bookingType))
-        .sort((a, b) => tidyTime(a.startTime).localeCompare(tidyTime(b.startTime)))
+        .sort((a, b) => (tidyTime(a.startTime) || '').localeCompare(tidyTime(b.startTime) || ''))
         .forEach((booking) => {
         const timeSlot = {
             startTime: extractTime$1(startTime.toISOString()),
@@ -42195,11 +42245,11 @@ function generateVirtualCourts(params) {
     const { courtBookings, unassignedBookings } = bookings.reduce((accumulator, booking) => {
         const { courtId } = booking;
         if (courtId) {
-            if (!accumulator.courtBookings[courtId]) {
-                accumulator.courtBookings[courtId] = [booking];
+            if (accumulator.courtBookings[courtId]) {
+                accumulator.courtBookings[courtId].push(booking);
             }
             else {
-                accumulator.courtBookings[courtId].push(booking);
+                accumulator.courtBookings[courtId] = [booking];
             }
         }
         else {
@@ -42233,8 +42283,7 @@ function generateVirtualCourts(params) {
         };
     });
     unassignedBookings.sort((a, b) => timeStringMinutes$1(a.startTime) - timeStringMinutes$1(b.startTime));
-    const getCourtTimeSlots = () => inProcessCourts
-        .map((court) => {
+    const getCourtTimeSlots = () => inProcessCourts.flatMap((court) => {
         const courtDate = court.dateAvailability;
         const { timeSlots = [] } = generateTimeSlots({ courtDate });
         return {
@@ -42242,8 +42291,7 @@ function generateVirtualCourts(params) {
             courtId: court.courtId,
             timeSlots,
         };
-    })
-        .flat();
+    });
     const assignedBookings = [];
     for (const unassignedBooking of unassignedBookings) {
         const { startTime, endTime, averageMinutes, recoveryMinutes, matchUpId } = unassignedBooking;
@@ -42340,7 +42388,7 @@ function getFirstTimeSlotStartTime({ averageMinutes, startTime, endTime, courts,
                 const available = timeSlotMinutes >= averageMinutes;
                 if (available) {
                     const timeString = extractTime$1(timeSlotStartTime.toISOString());
-                    if (!firstTimeSlotStartTime || timeString < firstTimeSlotStartTime) {
+                    if (timeString && (!firstTimeSlotStartTime || timeString < firstTimeSlotStartTime)) {
                         firstTimeSlotStartTime = timeString;
                     }
                 }
@@ -45282,15 +45330,15 @@ function addMatchUpScheduleItems(params) {
     let { matchUpDependencies, inContextMatchUps } = params;
     const { errorOnAnachronism = false, checkChronology = true, removePriorValues, tournamentRecords, tournamentRecord, drawDefinition, disableNotice, drawMatchUps, matchUpId, schedule, event, } = params;
     let matchUp, warning;
-    if (!drawMatchUps) {
+    if (drawMatchUps) {
+        matchUp = drawMatchUps.find((drawMatchUp) => drawMatchUp.matchUpId === matchUpId);
+    }
+    else {
         const result = findDrawMatchUp({ drawDefinition, event, matchUpId });
         if (result.error)
             return result;
         matchUp = result.matchUp;
     }
-    else {
-        matchUp = drawMatchUps.find((drawMatchUp) => drawMatchUp.matchUpId === matchUpId);
-    }
     const { endTime, courtId, courtIds, courtOrder, resumeTime, homeParticipantId, scheduledDate, scheduledTime, startTime, stopTime, timeModifiers, venueId, } = schedule;
     if (checkChronology && (!matchUpDependencies || !inContextMatchUps)) {
         ({ matchUpDependencies, matchUps: inContextMatchUps } = getMatchUpDependencies({
@@ -45304,11 +45352,11 @@ function addMatchUpScheduleItems(params) {
             priorMatchUpIds.includes(matchUp.matchUpId))
             .map(({ schedule }) => {
             const isoDateString = getIsoDateString(schedule);
-            return new Date(isoDateString).getTime();
+            return new Date(isoDateString ?? '').getTime();
         });
         if (priorMatchUpTimes?.length) {
             const isoDateString = getIsoDateString(schedule);
-            const matchUpTime = new Date(isoDateString).getTime();
+            const matchUpTime = new Date(isoDateString ?? '').getTime();
             const maxPriorMatchUpTime = Math.max(...priorMatchUpTimes);
             if (maxPriorMatchUpTime >= matchUpTime) {
                 if (errorOnAnachronism) {
@@ -45618,8 +45666,8 @@ function addMatchUpStopTime({ removePriorValues, tournamentRecord, drawDefinitio
     const relevantTimeItems = timeItems
         .filter((timeItem) => [START_TIME, RESUME_TIME, STOP_TIME].includes(timeItem?.itemType))
         .sort((a, b) => timeDate(a.itemValue, scheduledDate) - timeDate(b.itemValue, scheduledDate));
-    const lastRelevantTimeItem = relevantTimeItems[relevantTimeItems.length - 1];
-    const lastRelevantTimeItemIsStop = lastRelevantTimeItem && lastRelevantTimeItem.itemType === STOP_TIME;
+    const lastRelevantTimeItem = relevantTimeItems.at(-1);
+    const lastRelevantTimeItemIsStop = lastRelevantTimeItem?.itemType === STOP_TIME;
     const latestRelevantTimeValue = relevantTimeItems
         .filter((timeItem) => !lastRelevantTimeItemIsStop || timeItem.createdAt !== lastRelevantTimeItem.createdAt)
         .map((timeItem) => timeDate(timeItem.itemValue, scheduledDate))
@@ -45664,8 +45712,8 @@ function addMatchUpResumeTime({ removePriorValues, tournamentRecord, drawDefinit
     const relevantTimeItems = timeItems
         .filter((timeItem) => [START_TIME, RESUME_TIME, STOP_TIME].includes(timeItem?.itemType))
         .sort((a, b) => timeDate(a.itemValue, scheduledDate) - timeDate(b.itemValue, scheduledDate));
-    const lastRelevantTimeItem = relevantTimeItems[relevantTimeItems.length - 1];
-    const lastRelevantTimeItemIsResume = lastRelevantTimeItem && lastRelevantTimeItem.itemType === RESUME_TIME;
+    const lastRelevantTimeItem = relevantTimeItems.at(-1);
+    const lastRelevantTimeItemIsResume = lastRelevantTimeItem?.itemType === RESUME_TIME;
     const latestRelevantTimeValue = relevantTimeItems
         .filter((timeItem) => !lastRelevantTimeItemIsResume || timeItem.createdAt !== lastRelevantTimeItem.createdAt)
         .map((timeItem) => timeDate(timeItem.itemValue, scheduledDate))
@@ -47432,7 +47480,9 @@ function updateTimeAfterRecovery({ matchUpPotentialParticipantIds, individualPar
             participantId,
         });
         const matchUpTypeChange = individualParticipantProfiles[participantId].priorMatchUpType !== matchUp.matchUpType;
-        const recoveryValue = matchUpTypeChange ? typeChangeTimeAfterRecovery || timeAfterRecovery : timeAfterRecovery;
+        const recoveryValue = matchUpTypeChange
+            ? typeChangeTimeAfterRecovery || timeAfterRecovery
+            : timeAfterRecovery;
         if (potentialIndividualParticipantIds.includes(participantId)) {
             addParticipantPotentialRecovery({
                 individualParticipantProfiles,
@@ -47521,22 +47571,23 @@ function checkRequestConflicts({ averageMatchUpMinutes = 90, requestConflicts =
     const averageEnd = extractTime$1(addMinutes(scheduleStart, averageMatchUpMinutes).toISOString());
     for (const request of relevantPersonRequests) {
         const { requestId, startTime, endTime } = request;
-        const conflict = (scheduleTime > startTime && scheduleTime < endTime) || (averageEnd > startTime && averageEnd < endTime);
+        const conflict = (scheduleTime > startTime && scheduleTime < endTime) ||
+            (averageEnd && averageEnd > startTime && averageEnd < endTime);
         if (conflict) {
             conflicts.push({ matchUpId, request, scheduleTime });
-            if (!requestConflicts[requestId]) {
+            if (requestConflicts[requestId]) {
+                if (!requestConflicts[requestId].scheduleTimes.includes(scheduleTime))
+                    requestConflicts[requestId].scheduleTimes.push(scheduleTime);
+                if (!requestConflicts[requestId].matchUpIds.includes(matchUpId))
+                    requestConflicts[requestId].matchUpIds.push(matchUpId);
+            }
+            else {
                 requestConflicts[requestId] = {
                     request,
                     scheduleTimes: [scheduleTime],
                     matchUpIds: [matchUpId],
                 };
             }
-            else {
-                if (!requestConflicts[requestId].scheduleTimes.includes(scheduleTime))
-                    requestConflicts[requestId].scheduleTimes.push(scheduleTime);
-                if (!requestConflicts[requestId].matchUpIds.includes(matchUpId))
-                    requestConflicts[requestId].matchUpIds.push(matchUpId);
-            }
         }
     }
     return { conflicts };
@@ -48421,7 +48472,7 @@ function getEarliestCourtTime({ averageMinutes, startTime, endTime, court, date
         const available = timeSlotMinutes >= averageMinutes;
         if (available) {
             const timeString = extractTime$1(consideredStartTime.toISOString());
-            if (!first || timeString < first)
+            if (timeString && (!first || timeString < first))
                 first = timeString;
         }
         return first;
@@ -49662,7 +49713,7 @@ function generatePersonData(params) {
 function generatePersons(params) {
     let count = params?.count || 1;
     const { personExtensions, consideredDate, isMock = true, gendersCount, personData, category, sex } = params || {};
-    if (isNaN(count))
+    if (Number.isNaN(Number(count)))
         return { error: INVALID_VALUES };
     const maleCount = gendersCount?.[MALE] || (isMale(sex) && count) || 0;
     const femaleCount = gendersCount?.[FEMALE] || (isFemale(sex) && count) || 0;
@@ -49702,7 +49753,7 @@ function generatePersons(params) {
             if (person.nationalityCode &&
                 (typeof person.nationalityCode !== 'string' ||
                     person.nationalityCode.length > 3 ||
-                    !countries.find(({ iso, ioc }) => [iso, ioc].includes(person.nationalityCode))))
+                    !countries.some(({ iso, ioc }) => [iso, ioc].includes(person.nationalityCode))))
                 return false;
             if (person.nationalityCode)
                 nationalityCodes.push(person.nationalityCode);
@@ -50410,7 +50461,9 @@ function generateOutcome(params) {
         return { error: INVALID_VALUES };
     if (defaultWithScorePercent > 100)
         defaultWithScorePercent = 100;
-    if (isNaN(defaultWithScorePercent) || isNaN(pointsPerMinute) || isNaN(sideWeight))
+    if (Number.isNaN(Number(defaultWithScorePercent)) ||
+        Number.isNaN(Number(pointsPerMinute)) ||
+        Number.isNaN(Number(sideWeight)))
         return { error: INVALID_VALUES };
     const matchUpStatuses = Object.keys(matchUpStatusProfile).filter((matchUpStatus) => Object.keys(matchUpStatusConstants).includes(matchUpStatus) && matchUpStatus !== COMPLETED$1);
     const matchUpStatusTotals = Object.keys(matchUpStatuses).reduce((total, key) => total + matchUpStatusProfile[key], 0);
@@ -50531,9 +50584,7 @@ function generateSet({ weightedRange = [0, 1], pointsPerMinute, matchUpStatus, i
         return { set, incomplete, winningSideNumber };
     }
     else {
-        const range = generateRange(1, setTo + 1)
-            .map((value) => generateRange(0, setTo + 2 - value).map(() => value))
-            .flat();
+        const range = generateRange(1, setTo + 1).flatMap((value) => generateRange(0, setTo + 2 - value).map(() => value));
         const lowValue = range[randomInt(0, range.length - 1)];
         const scores = setTo &&
             getSetComplement({
@@ -50563,9 +50614,7 @@ function generateSet({ weightedRange = [0, 1], pointsPerMinute, matchUpStatus, i
         let tiebreakWinningSide;
         if (setAnalysis.hasTiebreakCondition || isTiebreakSet) {
             const { NoAD: tiebreakNoAd, tiebreakTo } = tiebreakFormat || tiebreakSet || {};
-            const range = generateRange(1, tiebreakTo + 1)
-                .map((value) => generateRange(0, tiebreakTo + 2 - value).map(() => value))
-                .flat();
+            const range = generateRange(1, tiebreakTo + 1).flatMap((value) => generateRange(0, tiebreakTo + 2 - value).map(() => value));
             const lowValue = range[randomInt(0, range.length - 1)];
             const scores = getTiebreakComplement({
                 isSide1: true,
@@ -55105,7 +55154,7 @@ function proAutoSchedule({ scheduleCompletedMatchUps, tournamentRecords, schedul
                 }
             }
         });
-        const availableCourts = Object.values(row).filter((c) => isObject(c) && !c.matchUpId);
+        const availableCourts = Object.values(row).filter((c) => isObject(c) && !c.matchUpId && !c.isBlocked);
         return gridRows.concat({
             matchUpIds,
             availableCourts,
@@ -56024,8 +56073,151 @@ function setMatchUpDailyLimits(params) {
     return { ...SUCCESS };
 }
 
+function addCourtGridBooking(params) {
+    const { tournamentRecord, disableNotice, scheduledDate, bookingType, courtOrder, rowCount = 1, courtId, notes, } = params;
+    if (!tournamentRecord) {
+        return decorateResult({
+            result: { error: INVALID_VALUES },
+            info: 'tournamentRecord is required',
+        });
+    }
+    if (!courtId) {
+        return { error: COURT_NOT_FOUND };
+    }
+    if (!scheduledDate) {
+        return decorateResult({
+            result: { error: INVALID_VALUES },
+            info: 'scheduledDate is required',
+        });
+    }
+    if (!bookingType) {
+        return decorateResult({
+            result: { error: INVALID_VALUES },
+            info: 'bookingType is required',
+        });
+    }
+    if (courtOrder === undefined || courtOrder === null) {
+        return decorateResult({
+            result: { error: INVALID_VALUES },
+            info: 'courtOrder is required',
+        });
+    }
+    if (!Number.isInteger(courtOrder) || courtOrder < 1) {
+        return decorateResult({
+            result: { error: INVALID_VALUES },
+            info: 'courtOrder must be a positive integer',
+        });
+    }
+    if (!Number.isInteger(rowCount) || rowCount < 1) {
+        return decorateResult({
+            result: { error: INVALID_VALUES },
+            info: 'rowCount must be a positive integer',
+        });
+    }
+    const { court, venue } = findCourt({ tournamentRecord, courtId });
+    if (!court)
+        return { error: COURT_NOT_FOUND };
+    const courtDate = getCourtDateAvailability({ court, date: scheduledDate });
+    if (!courtDate) {
+        if (!court.dateAvailability)
+            court.dateAvailability = [];
+        const newAvailability = {
+            date: scheduledDate,
+            bookings: [],
+        };
+        court.dateAvailability.push(newAvailability);
+    }
+    const targetCourtDate = getCourtDateAvailability({ court, date: scheduledDate });
+    if (targetCourtDate.bookings) {
+        for (const existingBooking of targetCourtDate.bookings) {
+            if (typeof existingBooking.courtOrder === 'number') {
+                const existingStart = existingBooking.courtOrder;
+                const existingEnd = existingStart + (existingBooking.rowCount || 1) - 1;
+                const newStart = courtOrder;
+                const newEnd = courtOrder + rowCount - 1;
+                if (newStart <= existingEnd && newEnd >= existingStart) {
+                    return decorateResult({
+                        result: { error: EXISTING_MATCHUPS },
+                        info: `Booking conflicts with existing booking at rows ${existingStart}-${existingEnd}`,
+                    });
+                }
+            }
+        }
+    }
+    const booking = {
+        courtOrder,
+        rowCount,
+        bookingType,
+        notes,
+        createdAt: new Date().toISOString(),
+    };
+    if (!targetCourtDate.bookings)
+        targetCourtDate.bookings = [];
+    targetCourtDate.bookings.push(booking);
+    if (!disableNotice && venue) {
+        addNotice({
+            payload: { venue, tournamentId: tournamentRecord.tournamentId },
+            topic: MODIFY_VENUE,
+            key: venue.venueId,
+        });
+    }
+    return { ...SUCCESS, booking };
+}
+
+function removeCourtGridBooking(params) {
+    const { tournamentRecord, disableNotice, scheduledDate, courtOrder, courtId, } = params;
+    if (!tournamentRecord) {
+        return decorateResult({
+            result: { error: INVALID_VALUES },
+            info: 'tournamentRecord is required',
+        });
+    }
+    if (!courtId) {
+        return { error: COURT_NOT_FOUND };
+    }
+    if (!scheduledDate) {
+        return decorateResult({
+            result: { error: INVALID_VALUES },
+            info: 'scheduledDate is required',
+        });
+    }
+    if (courtOrder === undefined || courtOrder === null) {
+        return decorateResult({
+            result: { error: INVALID_VALUES },
+            info: 'courtOrder is required',
+        });
+    }
+    const { court, venue } = findCourt({ tournamentRecord, courtId });
+    if (!court)
+        return { error: COURT_NOT_FOUND };
+    const courtDate = getCourtDateAvailability({ court, date: scheduledDate });
+    if (!courtDate?.bookings) {
+        return decorateResult({
+            result: { error: BOOKING_NOT_FOUND },
+            info: 'No bookings found for this date',
+        });
+    }
+    const bookingIndex = courtDate.bookings.findIndex((b) => b.courtOrder === courtOrder);
+    if (bookingIndex === -1) {
+        return decorateResult({
+            result: { error: BOOKING_NOT_FOUND },
+            info: `No booking found at row ${courtOrder}`,
+        });
+    }
+    const removed = courtDate.bookings.splice(bookingIndex, 1)[0];
+    if (!disableNotice && venue) {
+        addNotice({
+            payload: { venue, tournamentId: tournamentRecord.tournamentId },
+            topic: MODIFY_VENUE,
+            key: venue.venueId,
+        });
+    }
+    return { ...SUCCESS, booking: removed };
+}
+
 var mutate$3 = {
     __proto__: null,
+    addCourtGridBooking: addCourtGridBooking,
     addMatchUpCourtOrder: addMatchUpCourtOrder,
     addMatchUpEndTime: addMatchUpEndTime,
     addMatchUpOfficial: addMatchUpOfficial,
@@ -56053,6 +56245,7 @@ var mutate$3 = {
     modifyMatchUpFormatTiming: modifyMatchUpFormatTiming,
     proAutoSchedule: proAutoSchedule,
     proConflicts: proConflicts,
+    removeCourtGridBooking: removeCourtGridBooking,
     removeEventMatchUpFormatTiming: removeEventMatchUpFormatTiming,
     removeMatchUpCourtAssignment: removeMatchUpCourtAssignment,
     reorderUpcomingMatchUps: reorderUpcomingMatchUps,
@@ -56067,6 +56260,7 @@ var mutate$3 = {
 
 var index$5 = {
     __proto__: null,
+    addCourtGridBooking: addCourtGridBooking,
     addMatchUpCourtOrder: addMatchUpCourtOrder,
     addMatchUpEndTime: addMatchUpEndTime,
     addMatchUpOfficial: addMatchUpOfficial,
@@ -56105,6 +56299,7 @@ var index$5 = {
     proConflicts: proConflicts,
     publicFindCourt: publicFindCourt,
     query: query$4,
+    removeCourtGridBooking: removeCourtGridBooking,
     removeEventMatchUpFormatTiming: removeEventMatchUpFormatTiming,
     removeMatchUpCourtAssignment: removeMatchUpCourtAssignment,
     reorderUpcomingMatchUps: reorderUpcomingMatchUps,