tods-competition-factory 2.0.12 → 2.0.13

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

@@ -3497,10 +3497,9 @@ declare function getParticipantTimeItem({ returnPreviousValues, tournamentRecord
 };
 
 type IsAdHocArgs = {
-    drawDefinition?: DrawDefinition;
     structure?: any;
 };
-declare function isAdHoc({ drawDefinition, structure }: IsAdHocArgs): boolean;
+declare function isAdHoc({ structure }: IsAdHocArgs): boolean;
 
 declare const query$a_allPlayoffPositionsFilled: typeof allPlayoffPositionsFilled;
 declare const query$a_checkValidEntries: typeof checkValidEntries;

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.0.12';
+    return '2.0.13';
 }
 
 const SUCCESS = { success: true };
@@ -2209,6 +2209,7 @@ const errors = {
     [POLICY_DEFINITIONS]: MISSING_POLICY_DEFINITION,
     [DRAW_DEFINITION]: MISSING_DRAW_DEFINITION,
     [PARTICIPANT_ID]: MISSING_PARTICIPANT_ID,
+    [MATCHUP_FORMAT]: MISSING_MATCHUP_FORMAT,
     [TOURNAMENT_ID]: MISSING_TOURNAMENT_ID,
     [STRUCTURE_ID]: MISSING_STRUCTURE_ID,
     [MATCHUP_IDS]: MISSING_MATCHUP_IDS,
@@ -2252,7 +2253,7 @@ function checkRequiredParameters(params, requiredParams, stack) {
     const { paramError, errorParam } = findParamError(params, requiredParams);
     if (!paramError)
         return { valid: true };
-    const error = params[errorParam] === undefined
+    const error = params?.[errorParam] === undefined
         ? errors[errorParam] || INVALID_VALUES
         : (paramError.validate && paramError.invalid) || INVALID_VALUES;
     return decorateResult({
@@ -6594,17 +6595,16 @@ function isLucky({ roundsNotPowerOf2, drawDefinition, structure, matchUps }) {
         hasDrawPositions);
 }
 
-function isAdHoc({ drawDefinition, structure }) {
+function isAdHoc({ structure }) {
     if (!structure)
         return false;
     const matchUps = structure.matchUps || (structure.roundMatchUps && Object.values(structure.roundMatchUps).flat());
-    const hasRoundPosition = matchUps?.find((matchUp) => matchUp?.roundPosition);
-    const hasDrawPosition = matchUps?.find((matchUp) => matchUp?.drawPositions?.length);
-    return (!structure?.structures &&
+    const hasRoundPosition = !!matchUps?.find((matchUp) => matchUp?.roundPosition);
+    const hasDrawPosition = !!matchUps?.find((matchUp) => matchUp?.drawPositions?.length);
+    const adHoc = !structure?.structures &&
         structure?.stage !== VOLUNTARY_CONSOLATION &&
-        !(drawDefinition?.drawType && drawDefinition.drawType !== AD_HOC) &&
-        !hasRoundPosition &&
-        !hasDrawPosition);
+        (!matchUps.length || (!hasRoundPosition && !hasDrawPosition));
+    return adHoc;
 }
 
 const POLICY_ROUND_NAMING_DEFAULT = {
@@ -9785,6 +9785,9 @@ function allEventMatchUps(params) {
 }
 
 function allTournamentMatchUps(params) {
+    const paramsCheck = checkRequiredParameters(params, [{ tournamentRecord: true }]);
+    if (paramsCheck.error)
+        return paramsCheck;
     if (!params?.tournamentRecord)
         return { error: MISSING_TOURNAMENT_RECORD };
     let { participantMap, participants } = params;
@@ -10141,7 +10144,7 @@ function getStructureDrawPositionProfiles(params) {
             return result;
         structure = findContainer ? result.containingStructure ?? result.structure : result.structure;
     }
-    if (isAdHoc({ drawDefinition, structure })) {
+    if (isAdHoc({ structure })) {
         return { structure, isAdHoc: true, error: INVALID_DRAW_POSITION };
     }
     const { matchUps: inContextDrawMatchUps } = getAllDrawMatchUps({
@@ -12551,7 +12554,7 @@ function addDrawEntry(params) {
         drawDefinition,
         entryStatus,
     });
-    if (!ignoreStageSpace && !spaceAvailable.success) {
+    if (!ignoreStageSpace && !spaceAvailable.success && (!drawType || drawType !== AD_HOC)) {
         return { error: spaceAvailable.error };
     }
     if (extension && !isValidExtension({ extension }))
@@ -14838,7 +14841,7 @@ function assignDrawPosition$1({ provisionalPositioning, inContextDrawMatchUps, i
     const { structure } = result;
     if (!structure)
         return { error: STRUCTURE_NOT_FOUND };
-    if (isAdHoc({ drawDefinition, structure }))
+    if (isAdHoc({ structure }))
         return decorateResult({ result: { error: INVALID_MATCHUP }, stack });
     const { seedAssignments } = getStructureSeedAssignments({
         provisionalPositioning,
@@ -19578,18 +19581,18 @@ function calculatePercentages({ participantResults, matchUpFormat, tallyPolicy,
 function getParticipantResults({ participantIds, matchUpFormat, tallyPolicy, perPlayer, matchUps, }) {
     const participantResults = {};
     const excludeMatchUpStatuses = tallyPolicy?.excludeMatchUpStatuses || [];
-    const filteredMatchUps = matchUps.filter((matchUp) => {
+    const filteredMatchUps = matchUps?.filter((matchUp) => {
         return ((matchUp.tieMatchUps || !excludeMatchUpStatuses.includes(matchUp.matchUpStatus)) &&
             (!participantIds?.length ||
                 intersection(participantIds, [getSideId(matchUp, 0), getSideId(matchUp, 1)]).length === 2));
     });
-    const allSets = filteredMatchUps.flatMap(({ score, tieMatchUps }) => tieMatchUps
+    const allSets = filteredMatchUps?.flatMap(({ score, tieMatchUps }) => tieMatchUps
         ? tieMatchUps
             .filter(({ matchUpStatus }) => !excludeMatchUpStatuses.includes(matchUpStatus))
             .flatMap(({ score }) => score?.sets?.length ?? 0)
         : score?.sets?.length ?? 0);
-    const totalSets = allSets.reduce((a, b) => a + b, 0);
-    for (const matchUp of filteredMatchUps) {
+    const totalSets = allSets?.reduce((a, b) => a + b, 0);
+    for (const matchUp of filteredMatchUps ?? []) {
         const { matchUpStatus, tieMatchUps, tieFormat, score, winningSide, sides } = matchUp;
         const manualGamesOverride = tieFormat && matchUp._disableAutoCalc && tieFormat.collectionDefinitions.every(({ scoreValue }) => scoreValue);
         const winningParticipantId = winningSide && getWinningSideId(matchUp);
@@ -20486,7 +20489,7 @@ function modifyMatchUpScore(params) {
     }
     if (!matchUp.collectionId) {
         const isRoundRobin = structure?.structureType === CONTAINER;
-        const isAdHocStructure = isAdHoc({ drawDefinition, structure });
+        const isAdHocStructure = isAdHoc({ structure });
         if (isLucky({ drawDefinition, structure }) || isAdHocStructure || isRoundRobin) {
             const updateTally = (structure) => {
                 matchUpFormat = isDualMatchUp
@@ -20571,12 +20574,12 @@ function modifyMatchUpScore(params) {
 }
 
 function attemptToModifyScore(params) {
-    const { dualWinningSideChange, matchUpStatusCodes, drawDefinition, matchUpStatus, structure, matchUp } = params;
+    const { dualWinningSideChange, matchUpStatusCodes, matchUpStatus, structure, matchUp } = params;
     const matchUpStatusIsValid = isDirectingMatchUpStatus({ matchUpStatus }) ||
         ([CANCELLED$1, ABANDONED$1].includes(matchUpStatus) && dualWinningSideChange);
     const stack = 'attemptToModifyScore';
     const isCollectionMatchUp = Boolean(matchUp.collectionId);
-    const isAdHocMatchUp = isAdHoc({ drawDefinition, structure });
+    const isAdHocMatchUp = isAdHoc({ structure });
     const validToScore = isCollectionMatchUp || isAdHocMatchUp || drawPositionsAssignedParticipantIds({ structure, matchUp });
     if (!validToScore) {
         return { error: MISSING_ASSIGNMENTS };
@@ -21903,7 +21906,7 @@ function directParticipants(params) {
     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({ drawDefinition, structure });
+    const isAdHocMatchUp = isAdHoc({ structure });
     let drawPositions = matchUp.drawPositions;
     let annotate;
     if (isCollectionMatchUp) {
@@ -22841,12 +22844,18 @@ function deleteAdHocMatchUps(params) {
                 .flatMap((matchUp) => (matchUp.sides ?? []).map((side) => side.participantId))
                 .filter(Boolean)).map((participantId) => ({ participantId }));
             const matchUpFormat = structure?.matchUpFormat ?? drawDefinition?.matchUpFormat ?? event?.matchUpFormat;
+            const { matchUps } = getAllStructureMatchUps({
+                afterRecoveryTimes: false,
+                inContext: true,
+                structure,
+                event,
+            });
             const result = updateAssignmentParticipantResults({
                 positionAssignments: structure.positionAssignments,
-                matchUps: structure.matchUps,
                 tournamentRecord,
                 drawDefinition,
                 matchUpFormat,
+                matchUps,
                 event,
             });
             if (result.error)
@@ -22877,7 +22886,7 @@ function removeRoundMatchUps({ removeCompletedMatchUps, tournamentRecord, drawDe
     const structure = structureResult.structure;
     if (structure?.structures)
         return { error: INVALID_STRUCTURE };
-    const isAdHocStructure = isAdHoc({ drawDefinition, structure });
+    const isAdHocStructure = isAdHoc({ structure });
     if (isAdHocStructure) {
         return removeAdHocRound({
             tournamentId: tournamentRecord.tournamentId,
@@ -24367,7 +24376,7 @@ function adHocMatchUpActions({ restrictAdHocRoundParticipants, tournamentPartici
 function matchUpActions(params) {
     if (!params)
         return { error: INVALID_VALUES };
-    let drawDefinition, event;
+    let { drawDefinition, event } = params;
     const { restrictAdHocRoundParticipants = true, policyDefinitions: specifiedPolicyDefinitions, enforceGender, participantId, sideNumber, matchUpId, } = params;
     const tournamentRecord = params.tournamentRecord ??
         (params.tournamentId && isString(params.tournamentId) && params.tournamentRecords?.[params.tournamentId]);
@@ -24384,13 +24393,15 @@ function matchUpActions(params) {
         const matchUps = allTournamentMatchUps({ tournamentRecord }).matchUps ?? [];
         const matchUp = matchUps.find((matchUp) => matchUp.matchUpId === matchUpId);
         event = (tournamentRecord?.events ?? []).find((event) => event.eventId === matchUp?.eventId);
-        drawDefinition = (event?.drawDefinitions ?? []).find((drawDefinition) => drawDefinition.drawId === matchUp?.drawId);
+        const foundDrawDefinition = (event?.drawDefinitions ?? []).find((drawDefinition) => drawDefinition.drawId === matchUp?.drawId);
+        if (foundDrawDefinition)
+            drawDefinition = foundDrawDefinition;
     }
     if (!drawDefinition)
         return { error: MISSING_DRAW_DEFINITION };
     const tournamentParticipants = getParticipants({
-        tournamentRecord,
         withIndividualParticipants: true,
+        tournamentRecord,
     }).participants;
     const { drawId } = drawDefinition;
     const { matchUp, structure } = findDrawMatchUp({
@@ -24439,7 +24450,7 @@ function matchUpActions(params) {
     const validActions = [];
     if (!structureId)
         return { validActions };
-    const isAdHocMatchUp = isAdHoc({ drawDefinition, structure });
+    const isAdHocMatchUp = isAdHoc({ structure });
     const isCollectionMatchUp = matchUp.collectionId;
     if (isAdHocMatchUp && !isCollectionMatchUp) {
         const adHocValidActions = adHocMatchUpActions({
@@ -24580,6 +24591,7 @@ function matchUpActions(params) {
         structureIsComplete,
         validActions,
         isDoubleExit,
+        ...SUCCESS,
     };
 }
 
@@ -24635,13 +24647,10 @@ function getValidSwapAction({ onlyAssignedPositions = true, possiblyDisablingAct
 }
 
 function positionActions(params) {
+    const paramsCheck = checkRequiredParameters(params, [{ event: true, drawDefinition: true, structureId: true }]);
+    if (paramsCheck.error)
+        return paramsCheck;
     const { policyDefinitions: specifiedPolicyDefinitions, returnParticipants = true, provisionalPositioning, tournamentRecord, drawDefinition, drawPosition, event, } = params;
-    if (!event)
-        return { error: MISSING_EVENT };
-    if (!drawDefinition)
-        return { error: MISSING_DRAW_DEFINITION };
-    if (!params.structureId)
-        return { error: MISSING_STRUCTURE_ID };
     const tournamentParticipants = params.tournamentParticipants ??
         (tournamentRecord &&
             getParticipants({
@@ -24973,6 +24982,7 @@ function positionActions(params) {
         isDrawPosition: true,
         isByePosition,
         validActions,
+        ...SUCCESS,
     };
 }
 
@@ -35119,13 +35129,13 @@ function getStructure(params) {
         ?.filter((structure) => structure.stageSequence === 1)
         ?.reduce((targetStructure, structure) => {
         const orderNumber = structure.stage && stageOrder$1[structure.stage];
-        const structureIsAdHoc = isAdHoc({ drawDefinition, structure });
+        const structureIsAdHoc = isAdHoc({ structure });
         return structureIsAdHoc && orderNumber > (stageOrder$1[targetStructure?.stage] || 1) ? structure : targetStructure;
     }, undefined);
     const structure = drawDefinition?.structures?.find((structure) => structure.structureId === targetStructure?.structureId);
     if (!structure)
         return { error: STRUCTURE_NOT_FOUND };
-    const structureIsAdHoc = isAdHoc({ drawDefinition, structure });
+    const structureIsAdHoc = isAdHoc({ structure });
     if (!structureIsAdHoc)
         return { error: INVALID_DRAW_DEFINITION };
     return { structure };
@@ -35516,10 +35526,9 @@ function newDrawDefinition(params) {
 function setMatchUpMatchUpFormat(params) {
     let structureIds = params.structureIds;
     const { tournamentRecord, drawDefinition, matchUpFormat, structureId, matchUpId, event } = params;
-    if (!drawDefinition)
-        return { error: MISSING_DRAW_DEFINITION };
-    if (!matchUpFormat)
-        return { error: MISSING_MATCHUP_FORMAT };
+    const paramsCheck = checkRequiredParameters(params, [{ [DRAW_DEFINITION]: true, [MATCHUP_FORMAT]: true }]);
+    if (paramsCheck.error)
+        return paramsCheck;
     if (!isValidMatchUpFormat({ matchUpFormat }))
         return { error: UNRECOGNIZED_MATCHUP_FORMAT };
     const stack = 'setMatchUpFormat';
@@ -36725,22 +36734,19 @@ function getDrawData(params) {
             const { positionAssignments } = getPositionAssignments$1({
                 structure,
             });
-            let participantResults = positionAssignments
-                ?.filter(xa(PARTICIPANT_ID))
-                .map((assignment) => {
-                participantPlacements = true;
+            let participantResults = positionAssignments?.filter(xa(PARTICIPANT_ID)).map((assignment) => {
                 const { drawPosition, participantId } = assignment;
                 const { extension } = findExtension({
                     element: assignment,
                     name: TALLY,
                 });
-                return (extension && {
-                    drawPosition,
+                participantPlacements = true;
+                return {
+                    participantResult: extension?.value,
                     participantId,
-                    participantResult: extension.value,
-                });
-            })
-                .filter((f) => f?.participantResult);
+                    drawPosition,
+                };
+            });
             if (!participantResults?.length && matchUps.length && params.allParticipantResults) {
                 const { subOrderMap } = createSubOrderMap({ positionAssignments });
                 const result = tallyParticipantResults({
@@ -36749,17 +36755,15 @@ function getDrawData(params) {
                     subOrderMap,
                     matchUps,
                 });
-                participantResults = positionAssignments
-                    ?.map((assignment) => {
+                participantResults = positionAssignments?.filter(xa(PARTICIPANT_ID)).map((assignment) => {
                     const { drawPosition, participantId } = assignment;
-                    return (participantId &&
-                        result.participantResults?.[participantId] && {
-                        participantResult: result.participantResults[participantId],
+                    participantPlacements = true;
+                    return {
+                        participantResult: participantId && result.participantResults[participantId],
                         participantId,
                         drawPosition,
-                    });
-                })
-                    .filter((f) => f?.participantResult);
+                    };
+                });
             }
             const structureInfo = structure
                 ? (({ stageSequence, structureName, structureType, matchUpFormat, stage }) => ({
@@ -40486,7 +40490,7 @@ function removeDrawPosition({ inContextDrawMatchUps, positionAssignments, source
 function removeDirectedParticipants(params) {
     const { dualWinningSideChange, inContextDrawMatchUps, tournamentRecord, drawDefinition, matchUpStatus, matchUpsMap, dualMatchUp, targetData, matchUpId, structure, event, } = params;
     const isCollectionMatchUp = Boolean(params.matchUp.collectionId);
-    const isAdHocMatchUp = isAdHoc({ drawDefinition, structure });
+    const isAdHocMatchUp = isAdHoc({ structure });
     const { drawPositions, winningSide } = targetData.matchUp || {};
     if (!isAdHocMatchUp && !drawPositions) {
         return { error: MISSING_DRAW_POSITIONS };
@@ -42974,6 +42978,9 @@ function matchUpScore(params) {
 }
 
 function setMatchUpStatus(params) {
+    const paramsCheck = checkRequiredParameters(params, [{ [MATCHUP_ID]: true, [DRAW_DEFINITION]: true }]);
+    if (paramsCheck.error)
+        return paramsCheck;
     const tournamentRecords = resolveTournamentRecords(params);
     if (!params.drawDefinition) {
         const tournamentRecord = params.tournamentRecord ?? (params.tournamentId && tournamentRecords[params.tournamentId]);
@@ -42991,10 +42998,6 @@ function setMatchUpStatus(params) {
         params.event = result.event;
     }
     const { disableScoreValidation, policyDefinitions, tournamentRecord, disableAutoCalc, enableAutoCalc, drawDefinition, matchUpFormat, matchUpId, schedule, event, notes, } = params;
-    if (!drawDefinition)
-        return { error: MISSING_DRAW_ID };
-    if (!matchUpId)
-        return { error: MISSING_MATCHUP_ID };
     const { policy } = findPolicy({
         policyType: POLICY_TYPE_SCORING,
         tournamentRecord,
@@ -43004,6 +43007,9 @@ function setMatchUpStatus(params) {
         (policy?.allowChangePropagation !== undefined && policy.allowChangePropagation) ||
         undefined;
     const { outcome } = params;
+    if (outcome?.winningSide && ![1, 2].includes(outcome.winningSide)) {
+        return { error: INVALID_WINNING_SIDE };
+    }
     if (matchUpFormat) {
         const result = setMatchUpMatchUpFormat({
             tournamentRecord,
@@ -52977,6 +52983,31 @@ function modifyCollectionDefinition({ updateInProgressMatchUps = false, tourname
     return decorateResult({ result: { ...result, modifications }, stack });
 }
 
+function getTargetTeamMatchUps({ updateInProgressMatchUps, drawDefinition, structureId, structure, matchUpId, matchUp, }) {
+    let matchUps = [];
+    if (matchUpId && matchUp) {
+        matchUps = [matchUp];
+    }
+    else if (structureId && structure) {
+        matchUps =
+            getAllStructureMatchUps({
+                matchUpFilters: { matchUpTypes: [TEAM$1] },
+                structure,
+            })?.matchUps ?? [];
+    }
+    else if (drawDefinition) {
+        matchUps =
+            allDrawMatchUps({
+                matchUpFilters: { matchUpTypes: [TEAM$1] },
+                drawDefinition,
+            })?.matchUps ?? [];
+    }
+    const targetMatchUps = matchUps.filter((matchUp) => !matchUp.winningSide &&
+        matchUp.matchUpStatus !== COMPLETED$1 &&
+        (updateInProgressMatchUps || (matchUp.matchUpStatus !== IN_PROGRESS$1 && !checkScoreHasValue(matchUp))));
+    return { targetMatchUps };
+}
+
 function updateTargetTeamMatchUps({ updateInProgressMatchUps, tournamentRecord, drawDefinition, targetMatchUps, tieFormat, event, }) {
     for (const targetMatchUp of targetMatchUps) {
         const hasTieFormat = !!targetMatchUp.tieFormat;
@@ -53011,31 +53042,6 @@ function updateTargetTeamMatchUps({ updateInProgressMatchUps, tournamentRecord,
     return { ...SUCCESS };
 }
 
-function getTargetTeamMatchUps({ updateInProgressMatchUps, drawDefinition, structureId, structure, matchUpId, matchUp, }) {
-    let matchUps = [];
-    if (matchUpId && matchUp) {
-        matchUps = [matchUp];
-    }
-    else if (structureId && structure) {
-        matchUps =
-            getAllStructureMatchUps({
-                matchUpFilters: { matchUpTypes: [TEAM$1] },
-                structure,
-            })?.matchUps ?? [];
-    }
-    else if (drawDefinition) {
-        matchUps =
-            allDrawMatchUps({
-                matchUpFilters: { matchUpTypes: [TEAM$1] },
-                drawDefinition,
-            })?.matchUps ?? [];
-    }
-    const targetMatchUps = matchUps.filter((matchUp) => !matchUp.winningSide &&
-        matchUp.matchUpStatus !== COMPLETED$1 &&
-        (updateInProgressMatchUps || (matchUp.matchUpStatus !== IN_PROGRESS$1 && !checkScoreHasValue(matchUp))));
-    return { targetMatchUps };
-}
-
 function collectionGroupUpdate({ updateInProgressMatchUps, originalValueGoal, tournamentRecord, wasAggregateValue, tieFormatName, drawDefinition, structureId, structure, tieFormat, matchUpId, matchUp, eventId, event, }) {
     const { aggregateValue, valueGoal } = calculateWinCriteria(tieFormat);
     tieFormat.winCriteria = definedAttributes({ aggregateValue, valueGoal });