tods-competition-factory 2.0.34 → 2.0.36

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.0.34';
+    return '2.0.36';
 }
 
 function isFunction(obj) {
@@ -1873,7 +1873,7 @@ function checkRequiredParameters(params, requiredParams, stack) {
     if (!paramError)
         return { valid: true };
     const error = params?.[errorParam] === undefined
-        ? errors[errorParam] || INVALID_VALUES
+        ? errors[errorParam] || paramError[ERROR] || INVALID_VALUES
         : (paramError[VALIDATE] && paramError[INVALID]) || INVALID_VALUES;
     const param = errorParam ?? (paramError[ONE_OF] && Object.keys(paramError[ONE_OF]).join(', '));
     return decorateResult({
@@ -1917,10 +1917,10 @@ function findParamError(params, requiredParams) {
         const booleanParams = Object.keys(attrs).filter((key) => typeof attrs[key] === 'boolean');
         const invalidParam = booleanParams.find((param) => {
             const invalidValidationFunction = _validate && !isFunction(_validate);
-            const faliedTypeCheck = params[param] && !_validate && invalidType(params, param, _ofType);
-            const paramNotPresent = attrs[param] && !params[param];
+            const faliedTypeCheck = params[param] !== undefined && !_validate && invalidType(params, param, _ofType);
+            const paramNotPresent = attrs[param] && [undefined, null].includes(params[param]);
             const invalid = invalidValidationFunction || faliedTypeCheck || paramNotPresent;
-            const hasError = invalid || (_validate && params[param] && !checkValidation(params[param], _validate));
+            const hasError = invalid || (_validate && params[param] !== undefined && !checkValidation(params[param], _validate));
             if (hasError) {
                 errorParam = param;
                 paramInfo = _info;
@@ -7166,7 +7166,11 @@ function findEvent(params) {
     };
 }
 
-function getHomeParticipantId({ visibilityThreshold, timeStamp, schedule, matchUp }) {
+function getHomeParticipantId(params) {
+    const { visibilityThreshold, timeStamp, schedule, matchUp } = params;
+    const paramsCheck = checkRequiredParameters(params, [{ [MATCHUP]: true }]);
+    if (paramsCheck.error)
+        return paramsCheck;
     const { itemValue: homeParticipantId, timeStamp: itemTimeStamp } = latestVisibleTimeItemValue({
         timeItems: matchUp?.timeItems || [],
         itemType: HOME_PARTICIPANT_ID,
@@ -15376,13 +15380,7 @@ function checkRoundsArgs(params, additionalChecks) {
 }
 
 function shiftAdHocRounds(params) {
-    const check = checkRoundsArgs(params, [
-        {
-            targetRoundNumber: true,
-            roundNumber: true,
-            [OF_TYPE]: NUMBER,
-        },
-    ]);
+    const check = checkRoundsArgs(params, [{ targetRoundNumber: true, roundNumber: true, [OF_TYPE]: NUMBER }]);
     if (check.error)
         return check;
     const { structure, roundMatchUps, roundNumbers } = check;
@@ -19909,7 +19907,109 @@ function calculatePercentages({ participantResults, matchUpFormat, tallyPolicy,
     });
 }
 
-function getParticipantResults({ participantIds, matchUpFormat, tallyPolicy, perPlayer, matchUps, }) {
+const ELO = 'ELO';
+const NTRP = 'NTRP';
+const TRN = 'TRN';
+const UTR = 'UTR';
+const WTN = 'WTN';
+const ratingConstants = {
+    ELO,
+    NTRP,
+    TRN,
+    UTR,
+    WTN,
+};
+
+const ratingsParameters = {
+    [ELO]: {
+        defaultInitialization: 1500,
+        decimalsCount: 0,
+        range: [0, 3000],
+        ascending: true,
+    },
+    [NTRP]: {
+        accessors: ['ntrpRating', 'dntrpRatingHundredths'],
+        attributes: { ustaRatingType: '' },
+        accessor: 'dntrpRatingHundredths',
+        defaultInitialization: 3,
+        decimalsCount: 1,
+        ascending: true,
+        range: [1, 7],
+    },
+    [UTR]: {
+        defaultInitialization: 6,
+        accessors: ['utrRating'],
+        accessor: 'utrRating',
+        decimalsCount: 2,
+        ascending: true,
+        range: [1, 16],
+    },
+    [WTN]: {
+        attributes: { confidence: { generator: true, range: [60, 100] } },
+        accessors: ['wtnRating', 'confidence'],
+        defaultInitialization: 23,
+        accessor: 'wtnRating',
+        ascending: false,
+        decimalsCount: 2,
+        range: [40, 1],
+    },
+};
+
+function convertRange({ value, sourceRange, targetRange }) {
+    return (((value - sourceRange[0]) * (targetRange[1] - targetRange[0])) / (sourceRange[1] - sourceRange[0]) + targetRange[0]);
+}
+
+function getRatingConvertedToELO({ sourceRatingType, sourceRating }) {
+    const sourceRatingRange = ratingsParameters[sourceRatingType].range;
+    const invertedScale = sourceRatingRange[0] > sourceRatingRange[1];
+    const eloRatingRange = ratingsParameters[ELO].range;
+    return convertRange({
+        value: invertedScale ? sourceRatingRange[0] - sourceRating : sourceRating,
+        sourceRange: sourceRatingRange,
+        targetRange: eloRatingRange,
+    });
+}
+function getRatingConvertedFromELO({ targetRatingType, sourceRating }) {
+    const decimalPlaces = ratingsParameters[targetRatingType].decimalsCount || 0;
+    const targetRatingRange = ratingsParameters[targetRatingType].range;
+    const invertedScale = targetRatingRange[0] > targetRatingRange[1];
+    const eloRatingRange = ratingsParameters[ELO].range;
+    const result = convertRange({
+        targetRange: targetRatingRange,
+        sourceRange: eloRatingRange,
+        value: sourceRating,
+    });
+    const convertedRating = parseFloat(parseFloat(result).toFixed(decimalPlaces));
+    return invertedScale ? targetRatingRange[0] - convertedRating : convertedRating;
+}
+
+function getConvertedRating(params) {
+    const paramsCheck = checkRequiredParameters(params, [{ ratings: true, [OF_TYPE]: OBJECT }]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const matchUpType = params.matchUpType && [SINGLES, DOUBLES].includes(params.matchUpType) ? params.matchUpType : SINGLES;
+    const ratingTypes = Object.keys(ratingsParameters);
+    const targetRatingType = params.targetRatingType && ratingTypes.includes(params.targetRatingType) ? params.targetRatingType : ELO;
+    const sourceRatings = params.ratings[matchUpType]
+        ? params.ratings[matchUpType].reduce((sr, rating) => (sr.includes(rating.scaleName) ? sr : sr.concat(rating.scaleName)), [])
+        : [];
+    if (!sourceRatings)
+        return { error: NOT_FOUND };
+    const sourceRatingObject = params.ratings[matchUpType]?.find((rating) => rating.scaleName === targetRatingType) ??
+        params.ratings[matchUpType][0];
+    if (sourceRatings[0] === targetRatingType)
+        return sourceRatingObject;
+    const accessor = ratingsParameters[sourceRatingObject.scaleName].accessor;
+    const value = accessor ? sourceRatingObject.scaleValue[accessor] : sourceRatingObject.scaleValue;
+    const eloValue = getRatingConvertedToELO({ sourceRatingType: sourceRatingObject.scaleName, sourceRating: value });
+    const convertedRating = getRatingConvertedFromELO({
+        targetRatingType: targetRatingType,
+        sourceRating: eloValue,
+    });
+    return { convertedRating };
+}
+
+function getParticipantResults({ participantIds, pressureRating, matchUpFormat, tallyPolicy, perPlayer, matchUps, }) {
     const participantResults = {};
     const excludeMatchUpStatuses = tallyPolicy?.excludeMatchUpStatuses || [];
     const filteredMatchUps = matchUps?.filter((matchUp) => {
@@ -20029,11 +20129,13 @@ function getParticipantResults({ participantIds, matchUpFormat, tallyPolicy, per
                         matchUpFormat: tieMatchUp.matchUpFormat,
                         matchUpStatus: tieMatchUp.matchUpStatus,
                         score: tieMatchUp.score,
+                        sides: tieMatchUp.sides,
                         winningParticipantId,
                         losingParticipantId,
+                        manualGamesOverride,
                         participantResults,
                         isTieMatchUp: true,
-                        manualGamesOverride,
+                        pressureRating,
                         tallyPolicy,
                         winningSide,
                     });
@@ -20053,20 +20155,22 @@ function getParticipantResults({ participantIds, matchUpFormat, tallyPolicy, per
                     manualGamesOverride,
                     losingParticipantId,
                     participantResults,
+                    pressureRating,
                     matchUpStatus,
                     tallyPolicy,
                     winningSide,
                     score,
+                    sides,
                 });
             }
         }
+        const gamesWonSide1 = score?.sets?.reduce((total, set) => total + (set?.side1Score ?? 0), 0);
+        const gamesWonSide2 = score?.sets?.reduce((total, set) => total + (set.side2Score ?? 0), 0);
         if (manualGamesOverride) {
             const side1participantId = sides?.find(({ sideNumber }) => sideNumber === 1)?.participantId;
             const side2participantId = sides?.find(({ sideNumber }) => sideNumber === 2)?.participantId;
             checkInitializeParticipant(participantResults, side1participantId);
             checkInitializeParticipant(participantResults, side2participantId);
-            const gamesWonSide1 = score?.sets?.reduce((total, set) => total + (set?.side1Score ?? 0), 0);
-            const gamesWonSide2 = score?.sets?.reduce((total, set) => total + (set.side2Score ?? 0), 0);
             if (side1participantId) {
                 participantResults[side1participantId].gamesWon += gamesWonSide1;
                 participantResults[side1participantId].gamesLost += gamesWonSide2;
@@ -20119,6 +20223,7 @@ function checkInitializeParticipant(participantResults, participantId) {
             matchUpsWon: 0,
             pointsLost: 0,
             pointsWon: 0,
+            pressureScores: [],
             retirements: 0,
             setsLost: 0,
             setsWon: 0,
@@ -20157,9 +20262,22 @@ function processScore({ manualGamesOverride, participantResults, score, sides })
         }
     });
 }
-function processMatchUp({ winningParticipantId, losingParticipantId, participantResults, manualGamesOverride, matchUpFormat, matchUpStatus, isTieMatchUp, tallyPolicy, winningSide, score, }) {
+function processMatchUp({ winningParticipantId, manualGamesOverride, losingParticipantId, participantResults, pressureRating, matchUpFormat, matchUpStatus, isTieMatchUp, tallyPolicy, winningSide, score, sides, }) {
     const winningSideIndex = winningSide && winningSide - 1;
     const losingSideIndex = 1 - winningSideIndex;
+    if (pressureRating) {
+        const fixed2 = (value) => parseFloat(Number(Math.round(value * 1000) / 1000).toFixed(2));
+        const gamesWonSide1 = score?.sets?.reduce((total, set) => total + (set?.side1Score ?? 0), 0);
+        const gamesWonSide2 = score?.sets?.reduce((total, set) => total + (set.side2Score ?? 0), 0);
+        const side1 = sides.find(({ sideNumber }) => sideNumber === 1);
+        const side2 = sides.find(({ sideNumber }) => sideNumber === 2);
+        const side1ConvertedRating = getConvertedRating({ ratings: side1?.participant?.ratings }).convertedRating;
+        const side2ConvertedRating = getConvertedRating({ ratings: side2?.participant?.ratings }).convertedRating;
+        const side1Value = gamesWonSide1 * side2ConvertedRating;
+        const side2Value = gamesWonSide2 * side1ConvertedRating;
+        participantResults[side1?.participantId].pressureScores.push(fixed2(side1Value / (side1Value + side2Value)));
+        participantResults[side2?.participantId].pressureScores.push(fixed2(side1Value / (side1Value + side2Value)));
+    }
     if (!isTieMatchUp) {
         processOutcome$1({
             winningParticipantId,
@@ -20515,7 +20633,7 @@ function headToHeadWinner({ participantIds, participantResults }) {
     }
 }
 
-function tallyParticipantResults({ policyDefinitions, generateReport, matchUpFormat, matchUps = [], subOrderMap, perPlayer, }) {
+function tallyParticipantResults({ policyDefinitions, generateReport, pressureRating, matchUpFormat, matchUps = [], subOrderMap, perPlayer, }) {
     if (!matchUps?.length || !validMatchUps(matchUps))
         return { error: MISSING_MATCHUPS };
     const structureIds = unique(matchUps.map(({ structureId }) => structureId));
@@ -20536,6 +20654,7 @@ function tallyParticipantResults({ policyDefinitions, generateReport, matchUpFor
     const consideredMatchUps = matchUps.filter((matchUp) => checkMatchUpIsComplete({ matchUp }) || matchUp.matchUpType === TEAM$1);
     const { participantResults } = getParticipantResults({
         matchUps: consideredMatchUps,
+        pressureRating,
         matchUpFormat,
         tallyPolicy,
         perPlayer,
@@ -21209,7 +21328,7 @@ function tiebreakFormat(tieobject) {
 }
 
 function isValidMatchUpFormat({ matchUpFormat }) {
-    if (typeof matchUpFormat !== 'string')
+    if (!isString(matchUpFormat) || matchUpFormat === '')
         return false;
     const parsedFormat = parse(matchUpFormat);
     const setParts = matchUpFormat.match(/-S:([1-9])+\/TB([0-9]{1,2})@?([1-9]?)*/);
@@ -26350,55 +26469,7 @@ function addParticipantScaleItem({ removePriorValues, participant, scaleItem })
     return { ...SUCCESS, valueChanged, newValue: scaleItem.scaleValue };
 }
 
-const ELO = 'ELO';
-const NTRP = 'NTRP';
-const TRN = 'TRN';
-const UTR = 'UTR';
-const WTN = 'WTN';
-const ratingConstants = {
-    ELO,
-    NTRP,
-    TRN,
-    UTR,
-    WTN,
-};
-
-const ratingsParameters = {
-    [ELO]: {
-        defaultInitialization: 1500,
-        decimalsCount: 0,
-        range: [0, 3000],
-        ascending: true,
-    },
-    [NTRP]: {
-        accessors: ['ntrpRating', 'dntrpRatingHundredths'],
-        attributes: { ustaRatingType: '' },
-        accessor: 'dntrpRatingHundredths',
-        defaultInitialization: 3,
-        decimalsCount: 1,
-        ascending: true,
-        range: [1, 7],
-    },
-    [UTR]: {
-        defaultInitialization: 6,
-        accessors: ['utrRating'],
-        accessor: 'utrRating',
-        decimalsCount: 2,
-        ascending: true,
-        range: [1, 16],
-    },
-    [WTN]: {
-        attributes: { confidence: { generator: true, range: [60, 100] } },
-        accessors: ['wtnRating', 'confidence'],
-        defaultInitialization: 23,
-        accessor: 'wtnRating',
-        ascending: false,
-        decimalsCount: 2,
-        range: [40, 1],
-    },
-};
-
-const k538 = (countables) => 250 / Math.pow(countables + 5, 0.4);
+const k538 = (countables = 0) => 250 / Math.pow(countables + 5, 0.4);
 const kDefault = () => 1;
 function kSet(maxCountables = 3, counted = 2) {
     const kset = maxCountables / counted;
@@ -26412,12 +26483,12 @@ const eloConfig = {
     kDefault,
 };
 function calculateNewRatings(params) {
-    let { winnerRating, loserRating, ratingRange } = params;
+    let { winnerRating, loserRating } = params;
     const { ratings = ratingsParameters, winnerCountables = 1, loserCountables = 0, ratingType = ELO, maxCountables, countables, } = params || {};
     const ratingParameters = ratings?.[ratingType];
     if (!ratingParameters)
         return { error: MISSING_VALUE };
-    ratingRange = ratingParameters.range || ratingRange;
+    const ratingRange = ratingParameters.range || params.ratingRange;
     winnerRating = winnerRating || ratingParameters.defaultInitialization;
     loserRating = loserRating || ratingParameters.defaultInitialization;
     const invertedScale = ratingRange[0] > ratingRange[1];
@@ -26430,7 +26501,6 @@ function calculateNewRatings(params) {
         if (!inRange(ratingRange, loserRating))
             loserRating = ratingParameters.defaultInitialization;
     }
-    const convertRange = ({ value, sourceRange, targetRange }) => ((value - sourceRange[0]) * (targetRange[1] - targetRange[0])) / (sourceRange[1] - sourceRange[0]) + targetRange[0];
     const convertedWinnerRating = convertRange({
         targetRange: ratingsParameters[ELO].range,
         sourceRange: consideredRange,
@@ -33566,17 +33636,17 @@ function getCollectionsValue(definitions) {
             scoreValue,
             setValue,
         };
-        const valueKeys = Object.keys(valueAssignments).filter((key) => ![undefined, null].includes(valueAssignments[key]));
-        if (valueKeys.length !== 1) {
+        const valueKeys = Object.keys(valueAssignments).filter((key) => ![undefined, null].includes(valueAssignments[key]) &&
+            (!Array.isArray(valueAssignments[key]) || valueAssignments[key].length > 0));
+        if (valueKeys.length !== 1)
             invalidValues.push({ collectionId });
-        }
         const valueKey = valueKeys[0];
         if (valueKey) {
             const value = valueKey === 'collectionValueProfiles' ? Object.values(collectionValueProfiles) : valueAssignments[valueKey];
             assignmentValues.push({ valueKey, value });
         }
         totalMatchUps += matchUpCount;
-        if (collectionValueProfiles)
+        if (collectionValueProfiles?.length)
             return total + collectionValueProfiles.reduce((total, profile) => total + profile.value, 0);
         if (matchUpCount) {
             if (isConvertableInteger(matchUpValue))
@@ -33992,7 +34062,7 @@ function getDrawIsPublished({ publishStatus, drawId }) {
 }
 
 function getDrawData(params) {
-    const { tournamentParticipants = [], includePositionAssignments, policyDefinitions, tournamentRecord, inContext = true, usePublishState, status = PUBLIC, drawDefinition, noDeepCopy, sortConfig, context, event, } = params;
+    const { tournamentParticipants = [], includePositionAssignments, policyDefinitions, tournamentRecord, inContext = true, usePublishState, status = PUBLIC, pressureRating, refreshResults, drawDefinition, noDeepCopy, sortConfig, context, event, } = params;
     if (!drawDefinition)
         return { error: MISSING_DRAW_DEFINITION };
     const drawInfo = (({ matchUpFormat, updatedAt, drawType, drawName, drawId }) => ({
@@ -34070,11 +34140,12 @@ function getDrawData(params) {
                     drawPosition,
                 };
             });
-            if (!participantResults?.length && matchUps.length && params.allParticipantResults) {
+            if (matchUps.length && ((!participantResults?.length && params.allParticipantResults) || refreshResults)) {
                 const { subOrderMap } = createSubOrderMap({ positionAssignments });
                 const result = tallyParticipantResults({
                     matchUpFormat: structure.matchUpFormat,
                     policyDefinitions,
+                    pressureRating,
                     subOrderMap,
                     matchUps,
                 });
@@ -34102,14 +34173,14 @@ function getDrawData(params) {
             structureInfo.positionAssignments = positionAssignments;
             structureInfo.structureActive = matchUps.reduce((active, matchUp) => {
                 const activeMatchUpStatus = [
+                    DOUBLE_WALKOVER,
+                    DOUBLE_DEFAULT,
+                    IN_PROGRESS$1,
                     COMPLETED$1,
                     CANCELLED$1,
                     DEFAULTED,
                     RETIRED$1,
                     WALKOVER$2,
-                    IN_PROGRESS$1,
-                    DOUBLE_DEFAULT,
-                    DOUBLE_WALKOVER,
                 ].includes(matchUp.matchUpStatus);
                 return active || activeMatchUpStatus || !!matchUp.winningSide || !!matchUp.score?.scoreStringSide1;
             }, false);
@@ -34231,6 +34302,8 @@ function getEventData(params) {
         }))(getDrawData({
             allParticipantResults: params.allParticipantResults,
             context: { eventId, tournamentId, endDate },
+            pressureRating: params.pressureRating,
+            refreshResults: params.refreshResults,
             includePositionAssignments,
             tournamentParticipants,
             noDeepCopy: true,
@@ -36161,7 +36234,7 @@ function calculateWinCriteria({ collectionDefinitions = [], collectionGroups = [
         else if (typeof collectionValue === 'number' && isConvertableInteger(collectionValue)) {
             valueTotal += collectionValue;
         }
-        else if (collectionValueProfiles?.length) {
+        else if (Array.isArray(collectionValueProfiles) && collectionValueProfiles?.length) {
             for (const collectionValueProfile of collectionValueProfiles) {
                 valueTotal += collectionValueProfile.matchUpValue;
             }
@@ -36624,6 +36697,7 @@ var query$2 = {
     getCheckedInParticipantIds: getCheckedInParticipantIds,
     getCompetitionMatchUps: getCompetitionMatchUps,
     getEventMatchUpFormatTiming: getEventMatchUpFormatTiming,
+    getHomeParticipantId: getHomeParticipantId,
     getMatchUpCompetitiveProfile: getMatchUpCompetitiveProfile,
     getMatchUpContextIds: getMatchUpContextIds,
     getMatchUpDailyLimits: getMatchUpDailyLimits,
@@ -36979,6 +37053,7 @@ var index$f = {
     getEventTimeItem: getEventTimeItem,
     getEvents: getEvents,
     getFlightProfile: getFlightProfile,
+    getHomeParticipantId: getHomeParticipantId,
     getLinkedTournamentIds: getLinkedTournamentIds,
     getMatchUpCompetitiveProfile: getMatchUpCompetitiveProfile,
     getMatchUpContextIds: getMatchUpContextIds,
@@ -42662,10 +42737,22 @@ function scoreModification(params) {
 }
 
 function setMatchUpHomeParticipantId(params) {
+    const paramsCheck = checkRequiredParameters(params, [
+        { [TOURNAMENT_RECORD]: true, [DRAW_DEFINITION]: true, [MATCHUP_ID]: true },
+        { homeParticipantId: true, [ERROR]: MISSING_PARTICIPANT_ID },
+    ]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const resolutions = resolveFromParameters(params, [{ [PARAM]: MATCHUP, attr: { [IN_CONTEXT]: true } }]);
+    if (resolutions.error)
+        return resolutions;
+    const participantIds = resolutions?.matchUp?.matchUp?.sides?.map((side) => side?.participantId);
+    if (params.homeParticipantId && !participantIds?.includes(params.homeParticipantId))
+        return { error: INVALID_PARTICIPANT_ID };
     const { disableNotice = true, homeParticipantId, removePriorValues, tournamentRecord, drawDefinition, matchUpId, } = params;
     const timeItem = {
-        itemValue: homeParticipantId,
         itemType: HOME_PARTICIPANT_ID,
+        itemValue: homeParticipantId,
     };
     return addMatchUpTimeItem({
         duplicateValues: false,
@@ -44761,6 +44848,7 @@ var index$9 = {
     getCheckedInParticipantIds: getCheckedInParticipantIds,
     getCompetitionMatchUps: getCompetitionMatchUps,
     getEventMatchUpFormatTiming: getEventMatchUpFormatTiming,
+    getHomeParticipantId: getHomeParticipantId,
     getMatchUpCompetitiveProfile: getMatchUpCompetitiveProfile,
     getMatchUpContextIds: getMatchUpContextIds,
     getMatchUpDailyLimits: getMatchUpDailyLimits,
@@ -46955,6 +47043,7 @@ var lastNames = [
 	"Lem",
 	"Lovelace",
 	"Mander",
+	"McLuhan",
 	"Midgely",
 	"Mond",
 	"Montoya",
@@ -47113,6 +47202,7 @@ var firstMale = [
 	"Lief",
 	"Malachi",
 	"Mark",
+	"Marhsall",
 	"Masanobu",
 	"Maurits",
 	"Michael",
@@ -53865,7 +53955,7 @@ function modifyCollectionDefinition({ updateInProgressMatchUps = false, tourname
             stack,
         });
     const value = collectionValue ?? matchUpValue ?? scoreValue ?? setValue;
-    if (collectionValueProfiles) {
+    if (collectionValueProfiles?.length) {
         const result = validateCollectionValueProfiles({
             matchUpCount: matchUpCount ?? sourceCollectionDefinition?.matchUpCount ?? 0,
             collectionValueProfiles,
@@ -54194,7 +54284,7 @@ function getOrderedTieFormat({ tieFormat, orderMap }) {
         if (collectionOrder)
             collectionDefinition.collectionOrder = collectionOrder;
     });
-    orderedTieFormat.collectionDefinitions.sort((a, b) => numericSortValue(a.collectionOrder) - numericSortValue(b.collectionOrder));
+    orderedTieFormat.collectionDefinitions?.sort((a, b) => numericSortValue(a.collectionOrder) - numericSortValue(b.collectionOrder));
     return orderedTieFormat;
 }
 function orderCollectionDefinitions({ tournamentRecord, drawDefinition, structureId, matchUpId, orderMap, eventId, matchUp, event, }) {
@@ -54835,7 +54925,7 @@ function queueNoficiations({ modifiedStructureIds, tournamentRecord, modifiedMat
     });
 }
 
-function modifyTieFormat({ updateInProgressMatchUps = false, tieFormatComparison, modifiedTieFormat, tournamentRecord, drawDefinition, structureId, matchUpId, eventId, uuids, event, }) {
+function modifyTieFormat({ updateInProgressMatchUps = false, tieFormatComparison, modifiedTieFormat, tournamentRecord, considerations, drawDefinition, structureId, matchUpId, eventId, uuids, event, }) {
     const stack = 'modifyTieFormat';
     if (!validateTieFormat({ tieFormat: modifiedTieFormat }).valid) {
         return decorateResult({
@@ -54858,6 +54948,7 @@ function modifyTieFormat({ updateInProgressMatchUps = false, tieFormatComparison
     const comparison = compareTieFormats({
         descendant: modifiedTieFormat,
         ancestor: tieFormat,
+        considerations,
     });
     if (comparison.invalid) {
         return decorateResult({
@@ -57607,6 +57698,15 @@ const POLICY_SCORING_DEFAULT = {
                 },
             },
         },
+        matchUpFormats: [],
+        matchUpStatusCodes: {
+            [ABANDONED$1]: [],
+            [CANCELLED$1]: [],
+            [DEFAULTED]: [],
+            [INCOMPLETE]: [],
+            [RETIRED$1]: [],
+            [WALKOVER$2]: [],
+        },
     },
 };
 
@@ -57703,6 +57803,182 @@ const POLICY_SCORING_USTA = {
                 matchUpFormat: 'SET1-S:T20',
             },
         ],
+        matchUpStatusCodes: {
+            [ABANDONED$1]: [
+                {
+                    matchUpStatusCodeDisplay: 'Abandoned',
+                    label: 'Abandoned match',
+                    matchUpStatusCode: 'OA',
+                },
+            ],
+            [CANCELLED$1]: [
+                {
+                    matchUpStatusCodeDisplay: 'Unplayed or Cancelled',
+                    label: 'Cancelled match',
+                    matchUpStatusCode: 'OC',
+                },
+            ],
+            [INCOMPLETE]: [
+                {
+                    matchUpStatusCodeDisplay: 'Incomplete',
+                    label: 'Incomplete match',
+                    matchUpStatusCode: 'OI',
+                },
+            ],
+            [DEFAULTED]: [
+                {
+                    description: 'Disqualification for cause or ineligibility',
+                    label: 'Disqualification (ineligibility)',
+                    matchUpStatusCodeDisplay: 'Def [dq]',
+                    matchUpStatusCode: 'DQ',
+                },
+                {
+                    description: 'Misconduct before or between matches',
+                    label: 'Misconduct',
+                    matchUpStatusCodeDisplay: 'Def [cond]',
+                    matchUpStatusCode: 'DM',
+                },
+                {
+                    description: 'Failure to start match because of adult discipline',
+                    label: 'Fail. (adult discipline)',
+                    matchUpStatusCodeDisplay: 'Def [ad]',
+                    matchUpStatusCode: 'D5',
+                },
+                {
+                    description: 'Refusal to start match for reason other than adult discipline, injury, illness, or personal circumstance. ' +
+                        '(After the Referee has conclusively confirmed that a player refuses to play a match, the Referee need not ' +
+                        'wait until the scheduled time of the match to records the result.)',
+                    label: 'Refusal to start match',
+                    matchUpStatusCodeDisplay: 'Def [refsl]',
+                    matchUpStatusCode: 'D4',
+                },
+                {
+                    label: 'Not showing up',
+                    matchUpStatusCodeDisplay: 'Def [ns]',
+                    matchUpStatusCode: 'D6',
+                },
+                {
+                    description: 'Lateness for match including, but not limited to, intending to play but mistakenly arriving at the ' +
+                        'wrong time, location, or without proper equipment',
+                    label: 'Lateness for match',
+                    matchUpStatusCodeDisplay: 'Score + Def [late]',
+                    matchUpStatusCode: 'D7',
+                },
+                {
+                    label: 'Double default',
+                    matchUpStatusCodeDisplay: 'Def/Def',
+                    matchUpStatusCode: 'DD',
+                },
+                {
+                    description: 'Refusal to continue playing a match for reason other than injury, illness, personal circumstance, or ' +
+                        'adult discipline',
+                    label: 'Refusal to continue match',
+                    matchUpStatusCodeDisplay: 'Def [refsl]',
+                    matchUpStatusCode: 'D9',
+                },
+                {
+                    description: 'Default for receiving an injection, IV, or supplemental oxygen',
+                    label: 'Default (PEDs)',
+                    matchUpStatusCodeDisplay: 'Def [med]',
+                    matchUpStatusCode: 'DI',
+                },
+                {
+                    description: 'Default under Point Penalty System',
+                    label: 'Default (Point Penalty System)',
+                    matchUpStatusCodeDisplay: 'Def [pps]',
+                    matchUpStatusCode: 'DP',
+                },
+            ],
+            [WALKOVER$2]: [
+                {
+                    matchUpStatusCodeDisplay: 'Wo [inj]',
+                    matchUpStatusCode: 'W1',
+                    label: 'Injury',
+                },
+                {
+                    matchUpStatusCodeDisplay: 'Wo [ill]',
+                    matchUpStatusCode: 'W2',
+                    label: 'Illness',
+                },
+                {
+                    matchUpStatusCodeDisplay: 'Wo [pc]',
+                    label: 'Personal circumstance',
+                    matchUpStatusCode: 'W3',
+                },
+                {
+                    matchUpStatusCodeDisplay: 'Wo/Wo',
+                    matchUpStatusCode: 'WOWO',
+                    label: 'Double walkover',
+                },
+                {
+                    matchUpStatusCodeDisplay: 'Wo [Tae]',
+                    label: 'Tournament Administrative Error',
+                    matchUpStatusCode: 'W4',
+                },
+                {
+                    matchUpStatusCodeDisplay: 'Wo/Withdrawn',
+                    matchUpStatusCode: 'W5',
+                    label: 'Withdrawn',
+                },
+            ],
+            [RETIRED$1]: [
+                {
+                    matchUpStatusCodeDisplay: 'Ret [inj]',
+                    matchUpStatusCode: 'RJ',
+                    label: 'Injury',
+                },
+                {
+                    matchUpStatusCodeDisplay: 'Ret [ill]',
+                    matchUpStatusCode: 'RI',
+                    label: 'Illness',
+                },
+                {
+                    matchUpStatusCodeDisplay: 'Ret [pc]',
+                    label: 'Personal circumstance',
+                    matchUpStatusCode: 'RC',
+                },
+                {
+                    description: 'Retirement because of adult discipline',
+                    label: 'Ret. (adult discipline)',
+                    matchUpStatusCodeDisplay: 'Ret [ad]',
+                    matchUpStatusCode: 'RD',
+                },
+                {
+                    description: 'A player who retires from a match remains eligible for consolations, place playoffs, doubles and ' +
+                        'subsequent round robin matches',
+                    matchUpStatusCodeDisplay: 'Ret [elg]',
+                    label: 'Ret. (eligible)',
+                    matchUpStatusCode: 'RU',
+                },
+            ],
+            [WITHDRAWN]: [
+                {
+                    matchUpStatusCodeDisplay: 'Wd [inj]',
+                    matchUpStatusCode: 'WD.INJ',
+                    label: 'Injury',
+                },
+                {
+                    matchUpStatusCodeDisplay: 'Wd [ill]',
+                    matchUpStatusCode: 'WD.ILL',
+                    label: 'Illness',
+                },
+                {
+                    matchUpStatusCodeDisplay: 'Wd [pc]',
+                    label: 'Personal circumstance',
+                    matchUpStatusCode: 'WD.PC',
+                },
+                {
+                    matchUpStatusCodeDisplay: 'Wd/Wd',
+                    matchUpStatusCode: 'WD.WD',
+                    label: 'Double withdrawal',
+                },
+                {
+                    label: 'Tournament Administrative Error',
+                    matchUpStatusCodeDisplay: 'Wd [Tae]',
+                    matchUpStatusCode: 'WD.TAE',
+                },
+            ],
+        },
     },
 };