tods-competition-factory 2.0.59 → 2.0.60

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.0.59';
+    return '2.0.60';
 }
 
 function isFunction(obj) {
@@ -46,7 +46,7 @@ const hasAttributeValues = (a) => (o) => Object.keys(a).every((key) => o[key] ==
 function undefinedToNull(obj, shallow) {
     if (obj === undefined)
         return null;
-    if (typeof obj !== 'object' || obj === null)
+    if (!isObject(obj) || obj === null)
         return obj;
     const definedKeys = Object.keys(obj);
     const notNull = (value) => (value === undefined ? null : value);
@@ -62,7 +62,7 @@ function countKeys(o) {
     if (Array.isArray(o)) {
         return o.length + o.map(countKeys).reduce((a, b) => a + b, 0);
     }
-    else if (typeof o === 'object' && o !== null) {
+    else if (isObject(o) && o !== null) {
         return (Object.keys(o).length +
             Object.keys(o)
                 .map((k) => countKeys(o[k]))
@@ -20613,12 +20613,12 @@ const headToHeadTallyDirectives = [
 const GEMScoreValueMap = {
     matchUpsPct: 20,
     tieMatchUpsPct: 16,
-    setsPct: 12,
-    gamesPct: 8,
     pointsPct: 4,
+    gamesPct: 8,
+    setsPct: 12,
 };
 function getGroupOrder(params) {
-    const { requireCompletion = true, participantResults, subOrderMap, tallyPolicy } = params;
+    const { requireCompletion = true, participantResults, subOrderMap, tallyPolicy, } = params;
     const report = [];
     if (requireCompletion && !isComplete(params)) {
         return {};
@@ -20643,16 +20643,20 @@ function getGroupOrder(params) {
         attribute,
     });
     report.push({ attribute, groups: orderedTallyGroups });
-    const groupOrder = Object.keys(orderedTallyGroups)
+    const sortedTallyGroups = Object.keys(orderedTallyGroups)
         .map((key) => parseFloat(key))
         .sort((a, b) => b - a)
-        .map((key) => orderedTallyGroups[key])
-        .map((participantIds) => {
+        .map((key) => orderedTallyGroups[key]);
+    const sortedOrder = sortedTallyGroups.map((participantIds) => {
         const result = groupSubSort({ participantIds, ...params });
         report.push(...(result.report ?? []));
         return result.order;
-    })
-        .flat(Infinity);
+    });
+    const groupOrder = sortedOrder
+        .map((order, oi) => order.map((o) => (o.resolved ? o : { ...o, subGroup: [oi].concat(...(o.subGroup ?? [])) })))
+        .flat();
+    let lastSubGroup;
+    let subGroupCount = 0;
     let groupPosition = 1;
     let priorPositionResolution;
     groupOrder.forEach((finishingPosition, index) => {
@@ -20662,13 +20666,20 @@ function getGroupOrder(params) {
             groupPosition += 1;
         }
         priorPositionResolution = finishingPosition.resolved;
+        const subGroup = parseInt(finishingPosition.subGroup?.join('') || 0);
         if (finishingPosition.resolved) {
             finishingPosition.position = index + 1;
             groupPosition = finishingPosition.position;
         }
         else {
+            if (lastSubGroup && subGroup > lastSubGroup) {
+                groupPosition += subGroupCount;
+                subGroupCount = 0;
+            }
             finishingPosition.position = groupPosition;
+            subGroupCount += 1;
         }
+        lastSubGroup = subGroup;
     });
     const positions = groupOrder.map(({ position }) => position);
     const positionsCount = instanceCount(positions);
@@ -20717,11 +20728,11 @@ function processAttribute({ disableHeadToHead, participantIds, matchUpFormat, ta
     const report = [{ attribute, reversed, groups, idsFilter }];
     let order;
     if (Object.keys(groups).length > 1 && participantIds.length) {
-        order = Object.keys(groups)
+        const sortedTallyGroups = Object.keys(groups)
             .map((key) => parseFloat(key))
             .sort((a, b) => (reversed ? a - b : b - a))
-            .map((key) => groups[key])
-            .map((participantIds) => {
+            .map((key) => groups[key]);
+        const sortedOrder = sortedTallyGroups.map((participantIds) => {
             const result = groupSubSort({
                 participantResults,
                 disableHeadToHead,
@@ -20732,8 +20743,10 @@ function processAttribute({ disableHeadToHead, participantIds, matchUpFormat, ta
             });
             report.push(...(result.report ?? []));
             return result.order;
-        })
-            .flat(Infinity);
+        });
+        order = sortedOrder
+            .map((order, oi) => order.map((o) => (o.resolved ? o : { ...o, subGroup: [oi].concat(...(o.subGroup ?? [])) })))
+            .flat();
     }
     return { order, report };
 }
@@ -20749,11 +20762,11 @@ function groupSubSort({ participantResults, disableHeadToHead, participantIds, m
     }
     if (participantIds?.length === 2 &&
         (!tallyPolicy?.headToHead || (!tallyPolicy.headToHead.disabled && !disableHeadToHead))) {
-        const result = headToHeadWinner({ participantIds, participantResults });
+        const result = getHeadToHeadWinner({ participantIds, participantResults });
         if (result) {
             const headToHeadWinner = result[0].participantId;
             report.push({ attribute: 'head2Head', participantIds, headToHeadWinner });
-            return { order: [result], headToHeadWinner, report };
+            return { order: result, headToHeadWinner, report };
         }
     }
     const directives = tallyPolicy?.tallyDirectives || headToHeadTallyDirectives;
@@ -20786,7 +20799,7 @@ function groupSubSort({ participantResults, disableHeadToHead, participantIds, m
         report,
     };
 }
-function headToHeadWinner({ participantIds, participantResults }) {
+function getHeadToHeadWinner({ participantIds, participantResults }) {
     if (!participantIds)
         return;
     if (participantResults[participantIds[0]].victories.includes(participantIds[1])) {
@@ -20998,16 +21011,13 @@ function getMatchUp$1({ matchUps, matchUpId }) {
     return { matchUp };
 }
 
-function findDrawMatchUp({ tournamentParticipants, afterRecoveryTimes, contextContent, contextProfile, drawDefinition, matchUpsMap, matchUpId, inContext, context, event, }) {
-    if (!drawDefinition)
-        return { error: MISSING_DRAW_DEFINITION };
-    if (!matchUpId)
-        return { error: MISSING_MATCHUP_ID };
-    if (typeof matchUpId !== 'string')
-        return { error: INVALID_VALUES };
+function findDrawMatchUp(params) {
+    const paramsCheck = checkRequiredParameters(params, [{ [DRAW_DEFINITION]: true, [MATCHUP_ID]: true }]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const { tournamentParticipants, afterRecoveryTimes, contextProfile, drawDefinition, matchUpsMap, matchUpId, inContext, context, event, } = params;
     const { structures = [] } = getDrawStructures({ drawDefinition });
-    if (contextProfile && !contextContent)
-        contextContent = getContextContent({ contextProfile, drawDefinition });
+    const contextContent = params.contextContent || (contextProfile && getContextContent({ contextProfile, drawDefinition }));
     for (const structure of structures) {
         const { matchUps } = getAllStructureMatchUps({
             tournamentParticipants,
@@ -30547,13 +30557,13 @@ function validateScore({ existingMatchUpStatus, matchUpFormat, matchUpStatus, wi
                 [side1TiebreakScore, side2TiebreakScore],
                 [side1PointScore, side2PointScore],
             ]
-                .filter((pair) => pair.some((value) => value !== undefined))
+                .filter((pair) => pair.some((value) => ![undefined, null].includes(value)))
                 .every((pair) => pair.every((numericValue) => isConvertableInteger(numericValue)));
             if (!numericValuePairs) {
                 return { error: INVALID_VALUES, info: 'non-numeric values' };
             }
             const numericValues = [setNumber, winningSide]
-                .filter((value) => value !== undefined)
+                .filter((value) => ![undefined, null].includes(value))
                 .every((numericValue) => isConvertableInteger(numericValue));
             if (!numericValues) {
                 return { error: INVALID_VALUES, info: 'non-numeric values' };
@@ -46682,7 +46692,7 @@ function v2Scheduler({ schedulingProfileModifications, checkPotentialRequestConf
 }
 
 function clearScheduledMatchUps(params) {
-    const { scheduleAttributes = ['scheduledDate', 'scheduledTime'], ignoreMatchUpStatuses = completedMatchUpStatuses, scheduledDates, venueIds, } = params;
+    const { scheduleAttributes = ['scheduledDate', 'scheduledTime', 'courtOrder'], ignoreMatchUpStatuses = completedMatchUpStatuses, scheduledDates, venueIds, } = params;
     const tournamentRecords = resolveTournamentRecords(params);
     const tournamentIds = isObject(tournamentRecords)
         ? Object.values(tournamentRecords)
@@ -46707,7 +46717,7 @@ function clearScheduledMatchUps(params) {
     }
     return { ...SUCCESS, clearedScheduleCount };
 }
-function clearSchedules({ scheduleAttributes = ['scheduledDate', 'scheduledTime'], ignoreMatchUpStatuses = completedMatchUpStatuses, tournamentRecord, scheduledDates, venueIds = [], }) {
+function clearSchedules({ scheduleAttributes = ['scheduledDate', 'scheduledTime', 'courtOrder'], ignoreMatchUpStatuses = completedMatchUpStatuses, tournamentRecord, scheduledDates, venueIds = [], }) {
     if (typeof tournamentRecord !== 'object')
         return { error: MISSING_TOURNAMENT_RECORD };
     if (!Array.isArray(ignoreMatchUpStatuses) || !Array.isArray(venueIds)) {
@@ -46738,7 +46748,7 @@ function clearSchedules({ scheduleAttributes = ['scheduledDate', 'scheduledTime'
             let modified = false;
             matchUp.timeItems = (matchUp.timeItems ?? []).filter((timeItem) => {
                 const preserve = timeItem?.itemType &&
-                    ![ALLOCATE_COURTS, ASSIGN_COURT, ASSIGN_VENUE, SCHEDULED_DATE, SCHEDULED_TIME].includes(timeItem?.itemType);
+                    ![ALLOCATE_COURTS, ASSIGN_COURT, ASSIGN_VENUE, COURT_ORDER, SCHEDULED_DATE, SCHEDULED_TIME].includes(timeItem?.itemType);
                 if (!preserve)
                     modified = true;
                 return preserve;