tods-competition-factory 2.0.42 → 2.0.44

package/dist/tods-competition-factory.d.ts

@@ -5328,13 +5328,14 @@ type FindMatchUpResult = {
 };
 declare function publicFindMatchUp(params: FindMatchUpType): FindMatchUpResult;
 
-declare function applyLineUps({ tournamentRecord, drawDefinition, matchUpId, lineUps, event }: {
-    tournamentRecord: any;
-    drawDefinition: any;
-    matchUpId: any;
-    lineUps: any;
-    event: any;
-}): any;
+type ApplyLineUps = {
+    tournamentRecord: Tournament;
+    drawDefinition: DrawDefinition;
+    lineUps: TeamCompetitor[];
+    matchUpId: string;
+    event: Event$1;
+};
+declare function applyLineUps(params: ApplyLineUps): any;
 
 type ResetTieFormatArgs = {
     tournamentRecord: Tournament;
@@ -7782,9 +7783,11 @@ declare function getStructureReports({ firstFlightOnly, extensionProfiles, tourn
     };
     eventStructureReports?: undefined;
     structureReports?: undefined;
+    flightReports?: undefined;
 } | {
     eventStructureReports: unknown[];
     structureReports: any[] | undefined;
+    flightReports: any[];
     error?: undefined;
 };
 
@@ -8241,7 +8244,7 @@ declare function generateBookings({ defaultRecoveryMinutes, averageMatchUpMinute
     bookings: {
         recoveryMinutes: number | undefined;
         averageMinutes: number | undefined;
-        periodLength: number | undefined;
+        periodLength: number;
         startTime: any;
         courtId: any;
         endTime: any;
@@ -10446,6 +10449,8 @@ declare const fixtures: {
                         participantRole: boolean;
                         participantStatus: boolean;
                         penalties: boolean;
+                        rankings: boolean;
+                        ratings: boolean;
                         representing: boolean;
                         participantRoleResponsibilities: boolean;
                         participantType: boolean;
@@ -10481,6 +10486,8 @@ declare const fixtures: {
                     participantRole: boolean;
                     participantStatus: boolean;
                     penalties: boolean;
+                    rankings: boolean;
+                    ratings: boolean;
                     representing: boolean;
                     participantRoleResponsibilities: boolean;
                     participantType: boolean;
@@ -10623,7 +10630,8 @@ declare const fixtures: {
                     drawDefinitions: boolean;
                     structures: boolean;
                 };
-                requireAllPositionsAssigned: boolean;
+                requireParticipantsForScoring: boolean;
+                requireAllPositionsAssigned: undefined;
                 allowChangePropagation: boolean;
                 stage: {
                     MAIN: {

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.0.42';
+    return '2.0.44';
 }
 
 function isFunction(obj) {
@@ -19820,7 +19820,7 @@ function calculatePressureRatings({ participantResults, sides, score }) {
     const side2 = sides.find(({ sideNumber }) => sideNumber === 2);
     const side1ratings = side1?.participant?.ratings;
     const side2ratings = side2?.participant?.ratings;
-    if (side1ratings[SINGLES] && side2ratings[SINGLES]) {
+    if (side1ratings?.[SINGLES] && side2ratings?.[SINGLES]) {
         const targetRatingType = ELO;
         const { convertedRating: side1ConvertedRating } = getConvertedRating({ ratings: side1ratings, targetRatingType });
         const { convertedRating: side2ConvertedRating } = getConvertedRating({ ratings: side2ratings, targetRatingType });
@@ -21074,16 +21074,16 @@ function modifyMatchUpScore(params) {
 }
 
 function attemptToModifyScore(params) {
-    const { matchUpStatusCodes, matchUpStatus, structure, matchUp, dualMatchUp } = params;
+    const { matchUpStatusCodes, matchUpStatus, structure, matchUp, dualMatchUp, inContextMatchUp } = params;
     const matchUpStatusIsValid = isDirectingMatchUpStatus({ matchUpStatus }) ||
         ([CANCELLED$1, ABANDONED$1].includes(matchUpStatus) && dualMatchUp);
     const stack = 'attemptToModifyScore';
-    const isCollectionMatchUp = Boolean(matchUp.collectionId);
-    const isAdHocMatchUp = isAdHoc({ structure });
-    const validToScore = isCollectionMatchUp || isAdHocMatchUp || drawPositionsAssignedParticipantIds({ structure, matchUp });
-    if (!validToScore) {
-        return { error: MISSING_ASSIGNMENTS };
-    }
+    const hasAdHocSides = isAdHoc({ structure }) && matchUp?.sides?.every((side) => side.participantId);
+    const validToScore = hasAdHocSides ||
+        drawPositionsAssignedParticipantIds({ structure, matchUp, inContextMatchUp }) ||
+        params.appliedPolicies?.[POLICY_TYPE_SCORING]?.requireParticipantsForScoring === false;
+    if (!validToScore)
+        return decorateResult({ result: { error: MISSING_ASSIGNMENTS }, stack });
     const removeScore = [WALKOVER$2].includes(matchUpStatus);
     const updatedMatchUpStatus = matchUpStatusIsValid ? matchUpStatus : (params.winningSide && COMPLETED$1) || INCOMPLETE;
     const result = modifyMatchUpScore({
@@ -21095,13 +21095,14 @@ function attemptToModifyScore(params) {
     });
     return decorateResult({ result, stack });
 }
-function drawPositionsAssignedParticipantIds({ structure, matchUp }) {
+function drawPositionsAssignedParticipantIds({ structure, matchUp, inContextMatchUp }) {
     const { drawPositions } = matchUp;
     const { positionAssignments } = structureAssignedDrawPositions({ structure });
     const assignedParticipantIds = positionAssignments?.filter((assignment) => {
         return drawPositions?.includes(assignment.drawPosition) && assignment.participantId;
     });
-    return assignedParticipantIds?.length === 2;
+    const bothSidesPresent = inContextMatchUp?.sides?.every((side) => side.participantId);
+    return assignedParticipantIds?.length === 2 || bothSidesPresent;
 }
 
 function getGroupValueGroups({ collectionGroups = [] }) {
@@ -22398,14 +22399,14 @@ function directLoser(params) {
 }
 
 function directParticipants(params) {
+    const stack = 'directParticipants';
     const result = attemptToModifyScore(params);
     if (result.error)
-        return result;
+        return decorateResult({ result, stack });
     const matchUpStatusIsValid = isDirectingMatchUpStatus({
         matchUpStatus: params.matchUpStatus,
     });
     const { dualWinningSideChange, projectedWinningSide, inContextDrawMatchUps, tournamentRecord, drawDefinition, matchUpStatus, dualMatchUp, matchUpsMap, winningSide, targetData, matchUpId, structure, matchUp, event, } = params;
-    const stack = 'directParticipants';
     const isCollectionMatchUp = Boolean(matchUp.collectionId);
     const isAdHocMatchUp = isAdHoc({ structure });
     let drawPositions = matchUp.drawPositions;
@@ -24169,7 +24170,7 @@ function collectionMatchUpActions({ specifiedPolicyDefinitions, inContextDrawMat
         .filter(Boolean);
     const existingParticipantIds = existingParticipants?.map(getParticipantId);
     const inContextDualMatchUp = inContextDrawMatchUps?.find((drawMatchUp) => drawMatchUp.matchUpId === inContextMatchUp.matchUpTieId);
-    const availableIndividualParticipants = inContextDualMatchUp?.sides?.map((side) => side.participant?.individualParticipants.filter(({ participantId, person }) => !existingParticipantIds?.includes(participantId) &&
+    const availableIndividualParticipants = inContextDualMatchUp?.sides?.map((side) => side?.participant?.individualParticipants?.filter(({ participantId, person }) => !existingParticipantIds?.includes(participantId) &&
         (!gender ||
             gender === ANY ||
             person.sex === gender ||
@@ -34201,7 +34202,7 @@ function getDrawData(params) {
                     const { drawPosition, participantId } = assignment;
                     participantPlacements = true;
                     return {
-                        participantResult: participantId && result.participantResults[participantId],
+                        participantResult: participantId && result?.participantResults?.[participantId],
                         participantId,
                         drawPosition,
                     };
@@ -41343,8 +41344,10 @@ function removeTieMatchUpParticipantId(params) {
         side.participant?.individualParticipantIds?.includes(participantId));
     if (!side)
         return decorateResult({ result: { error: PARTICIPANT_NOT_FOUND }, stack });
+    const scoringPolicy = params.policyDefinitions?.[POLICY_TYPE_SCORING] ?? appliedPolicies?.[POLICY_TYPE_SCORING];
     if (!side.substitutions?.length &&
-        (checkScoreHasValue({ score: inContextTieMatchUp?.score }) || inContextTieMatchUp?.winningSide))
+        (checkScoreHasValue({ score: inContextTieMatchUp?.score }) || inContextTieMatchUp?.winningSide) &&
+        !(scoringPolicy?.requireParticipantsForScoring === false))
         return decorateResult({ result: { error: EXISTING_OUTCOME }, stack });
     const teamParticipantId = inContextDualMatchUp?.sides?.find(({ sideNumber }) => sideNumber === side.sideNumber)?.participantId;
     if (!teamParticipantId)
@@ -43678,35 +43681,25 @@ function setMatchUpState(params) {
             return result;
         }
     }
-    const positionAssignments = !matchUp?.sides
-        ? getPositionAssignments$1({
-            drawDefinition,
-            structureId,
-        }).positionAssignments
-        : [];
-    const participantsCount = inContextMatchUp?.sides?.map((side) => side.participantId).filter(Boolean).length;
-    const requiredParticipants = (participantsCount && participantsCount === 2) ||
-        (matchUp.collectionId && isAdHoc({ structure }) && participantsCount && participantsCount >= 1) ||
-        (assignedDrawPositions?.length === 2 &&
-            positionAssignments
-                ?.filter((assignment) => assignedDrawPositions.includes(assignment.drawPosition))
-                .every((assignment) => assignment.participantId));
-    if (matchUpStatus && particicipantsRequiredMatchUpStatuses.includes(matchUpStatus) && !requiredParticipants) {
-        return decorateResult({
-            info: 'present in participantsRequiredMatchUpStatuses',
-            context: { matchUpStatus, requiredParticipants },
-            result: { error: INVALID_MATCHUP_STATUS },
-        });
-    }
     const appliedPolicies = getAppliedPolicies({
         policyTypes: [POLICY_TYPE_PROGRESSION, POLICY_TYPE_SCORING],
         tournamentRecord,
         drawDefinition,
         event,
     })?.appliedPolicies ?? {};
-    if (typeof params.policyDefinitions === 'object') {
+    if (isObject(params.policyDefinitions))
         Object.assign(appliedPolicies, params.policyDefinitions);
-    }
+    const participantCheck = checkParticipants({
+        assignedDrawPositions,
+        inContextMatchUp,
+        appliedPolicies,
+        drawDefinition,
+        matchUpStatus,
+        structure,
+        matchUp,
+    });
+    if (participantCheck?.error)
+        return participantCheck;
     const qualifyingMatch = inContextMatchUp?.stage === QUALIFYING && inContextMatchUp.finishingRound === 1;
     const qualifierAdvancing = qualifyingMatch && winningSide;
     const removingQualifier = qualifyingMatch &&
@@ -43878,6 +43871,31 @@ function applyMatchUpValues(params) {
     }
     return result;
 }
+function checkParticipants({ assignedDrawPositions, inContextMatchUp, appliedPolicies, drawDefinition, matchUpStatus, structure, matchUp, }) {
+    if (appliedPolicies?.[POLICY_TYPE_SCORING]?.requireParticipantsForScoring === false)
+        return { ...SUCCESS };
+    const participantsCount = inContextMatchUp?.sides?.map((side) => side.participantId).filter(Boolean).length;
+    const positionAssignments = !matchUp?.sides
+        ? getPositionAssignments$1({
+            structureId: structure?.structureId,
+            drawDefinition,
+        }).positionAssignments
+        : [];
+    const requiredParticipants = (participantsCount && participantsCount === 2) ||
+        (matchUp.collectionId && isAdHoc({ structure }) && participantsCount && participantsCount >= 1) ||
+        (assignedDrawPositions?.length === 2 &&
+            positionAssignments
+                ?.filter((assignment) => assignedDrawPositions.includes(assignment.drawPosition))
+                .every((assignment) => assignment.participantId));
+    if (matchUpStatus && particicipantsRequiredMatchUpStatuses.includes(matchUpStatus) && !requiredParticipants) {
+        return decorateResult({
+            info: 'matchUpStatus requires assigned participants',
+            context: { matchUpStatus, requiredParticipants },
+            result: { error: INVALID_MATCHUP_STATUS },
+        });
+    }
+    return { ...SUCCESS };
+}
 
 function enableTieAutoCalc({ tournamentRecord, drawDefinition, matchUpId, event }) {
     if (!drawDefinition)
@@ -44711,16 +44729,15 @@ function setOrderOfFinish(params) {
     return setOrderOfFinish$1(params);
 }
 
-function applyLineUps({ tournamentRecord, drawDefinition, matchUpId, lineUps, event }) {
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    if (!drawDefinition)
-        return { error: DRAW_DEFINITION_NOT_FOUND };
-    if (typeof matchUpId !== 'string')
-        return { error: INVALID_MATCHUP };
-    if (!Array.isArray(lineUps))
-        return { error: INVALID_VALUES, lineUps };
+function applyLineUps(params) {
+    const { tournamentRecord, drawDefinition, matchUpId, lineUps, event } = params;
     const stack = 'applyLineUps';
+    const paramsCheck = checkRequiredParameters(params, [
+        { [TOURNAMENT_RECORD]: true, [DRAW_DEFINITION]: true, [MATCHUP_ID]: true },
+        { lineUps: true, [OF_TYPE]: ARRAY },
+    ], stack);
+    if (paramsCheck.error)
+        return paramsCheck;
     const tournamentParticipants = tournamentRecord.participants || [];
     let result = findDrawMatchUp({
         tournamentParticipants,
@@ -47048,6 +47065,7 @@ var lastNames = [
 	"Bennett",
 	"Berry",
 	"Bonaparte",
+	"Brewer",
 	"Brockovich",
 	"Bukowski",
 	"Cassidy",
@@ -52155,7 +52173,10 @@ function getAvgWTN({ eventType, matchUps, eventId, drawId }) {
 function getStructureReports({ firstFlightOnly = true, extensionProfiles, tournamentRecord, }) {
     if (!tournamentRecord)
         return { error: MISSING_TOURNAMENT_ID };
+    const mainStructures = [];
+    const structureManipulations = {};
     const eventStructureReports = {};
+    const flightReports = [];
     const extensionValues = Object.assign({}, ...(extensionProfiles ?? []).map(({ name, label, accessor }) => {
         const element = findExtension({
             element: tournamentRecord,
@@ -52178,7 +52199,16 @@ function getStructureReports({ firstFlightOnly = true, extensionProfiles, tourna
         })?.timeItem;
         return timeItem?.itemValue?.scaleBasis;
     };
-    const tournamentStructureData = tournamentRecord?.events?.flatMap(({ timeItems: eventTimeItems, drawDefinitions = [], extensions, eventType, eventId, category }) => {
+    const updateStructureManipulations = ({ positionManipulations }) => {
+        positionManipulations?.forEach((action) => {
+            const { structureId, name } = action;
+            const drawPositions = action.drawPositions || [action.drawPosition];
+            if (!structureManipulations[structureId])
+                structureManipulations[structureId] = [];
+            structureManipulations[structureId].push(`${name}: ${drawPositions.join('/')}`);
+        });
+    };
+    const tournamentStructureData = tournamentRecord?.events?.flatMap(({ timeItems: eventTimeItems, drawDefinitions = [], extensions, eventType, eventName, eventId, category }) => {
         const flightProfile = extensions?.find((x) => x.name === FLIGHT_PROFILE);
         const flightNumbers = flightProfile?.value?.flights?.map((flight) => ({
             [flight.drawId]: flight.flightNumber,
@@ -52200,17 +52230,16 @@ function getStructureReports({ firstFlightOnly = true, extensionProfiles, tourna
         return (drawDefinitions
             .filter((d) => !firstFlightOnly || !flightNumbers || flightMap[d.drawId] === minFlightNumber)
             .flatMap((dd) => {
-            const { matchUpFormat: drawMatchUpFormat, tieFormat: drawTieFormat, timeItems: drawTimeItems, extensions, structures, drawType, drawId, } = dd;
+            const { matchUpFormat: drawMatchUpFormat, tieFormat: drawTieFormat, timeItems: drawTimeItems, extensions, structures, drawName, drawType, drawId, } = dd;
             const { matchUpFormatCounts, matchUpsCount, avgConfidence, pctNoRating, avgWTN } = getAvgWTN({
                 eventType,
                 matchUps,
                 drawId,
             });
             const seedingBasis = getSeedingBasis(drawTimeItems) || eventSeedingBasis;
-            const positionManipulations = getPositionManipulations({
-                extensions,
-            });
+            const positionManipulations = getPositionManipulations({ extensions });
             const manipulationsCount = positionManipulations?.length || 0;
+            updateStructureManipulations({ positionManipulations });
             eventStructureReports[eventId].totalPositionManipulations += manipulationsCount;
             eventStructureReports[eventId].generatedDrawsCount += 1;
             if (manipulationsCount > eventStructureReports[eventId].maxPositionManipulations)
@@ -52221,6 +52250,8 @@ function getStructureReports({ firstFlightOnly = true, extensionProfiles, tourna
                 const finalMatchUp = [MAIN, PLAY_OFF].includes(s.stage)
                     ? matchUps.find((matchUp) => matchUp.structureId === s.structureId && matchUp.finishingRound === 1 && matchUp.winningSide)
                     : undefined;
+                if (s.stage === MAIN)
+                    mainStructures.push({ eventName, drawName, structureId: s.structureId });
                 const winningSide = finalMatchUp?.sides?.find((side) => side.sideNumber === finalMatchUp.winningSide);
                 const winningParticipant = winningSide?.participant;
                 const winningTeamId = winningParticipant?.participantType === TEAM_PARTICIPANT && winningParticipant.participantId;
@@ -52285,9 +52316,14 @@ function getStructureReports({ firstFlightOnly = true, extensionProfiles, tourna
             });
         }));
     });
+    mainStructures.forEach(({ eventName, drawName, structureId }) => {
+        if (structureManipulations[structureId]?.length)
+            flightReports.push({ eventName, drawName, actions: structureManipulations[structureId] });
+    });
     return {
         eventStructureReports: Object.values(eventStructureReports),
         structureReports: tournamentStructureData,
+        flightReports,
     };
 }
 function getPositionManipulations({ extensions }) {
@@ -57670,6 +57706,8 @@ const POLICY_PRIVACY_DEFAULT = {
                 participantRole: true,
                 participantStatus: true,
                 penalties: false,
+                rankings: true,
+                ratings: true,
                 representing: true,
                 participantRoleResponsibilities: false,
                 participantType: true,
@@ -57705,6 +57743,8 @@ const POLICY_PRIVACY_DEFAULT = {
             participantRole: true,
             participantStatus: true,
             penalties: false,
+            rankings: true,
+            ratings: true,
             representing: true,
             participantRoleResponsibilities: false,
             participantType: true,
@@ -57743,7 +57783,8 @@ const POLICY_SCORING_DEFAULT = {
             drawDefinitions: false,
             structures: false,
         },
-        requireAllPositionsAssigned: false,
+        requireParticipantsForScoring: false,
+        requireAllPositionsAssigned: undefined,
         allowChangePropagation: false,
         stage: {
             [MAIN]: {