tods-competition-factory 2.1.30 → 2.2.1

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

@@ -2387,6 +2387,7 @@ type GroupsMatchUpsResult = {
     abandonedMatchUps?: HydratedMatchUp[];
     completedMatchUps?: HydratedMatchUp[];
     upcomingMatchUps?: HydratedMatchUp[];
+    participants?: HydratedParticipant[];
     pendingMatchUps?: HydratedMatchUp[];
     byeMatchUps?: HydratedMatchUp[];
     matchUpsMap?: MatchUpsMap;
@@ -5585,6 +5586,9 @@ type CompetitionScheduleMatchUpsArgs = {
     status?: string;
 };
 declare function competitionScheduleMatchUps(params: CompetitionScheduleMatchUpsArgs): {
+    mappedParticipants?: {
+        [key: string]: HydratedParticipant;
+    };
     completedMatchUps?: HydratedMatchUp[];
     dateMatchUps?: HydratedMatchUp[];
     courtPrefix?: string;
@@ -5685,6 +5689,7 @@ declare function allCompetitionMatchUps({ scheduleVisibilityFilters, afterRecove
 type GetAllStructureMatchUps = {
     scheduleVisibilityFilters?: ScheduleVisibilityFilters;
     tournamentAppliedPolicies?: PolicyDefinitions;
+    participantsProfile?: ParticipantsProfile;
     tournamentParticipants?: Participant[];
     policyDefinitions?: PolicyDefinitions;
     seedAssignments?: SeedAssignment[];
@@ -5702,6 +5707,7 @@ type GetAllStructureMatchUps = {
     contextProfile?: ContextProfile;
     tournamentRecord?: Tournament;
     afterRecoveryTimes?: boolean;
+    useParticipantMap?: boolean;
     usePublishState?: boolean;
     exitProfiles?: ExitProfiles;
     matchUpsMap?: MatchUpsMap;
@@ -5772,11 +5778,15 @@ type CompetitionMatchUpsArgs = {
     contextFilters?: MatchUpFilters;
     hydrateParticipants?: boolean;
     afterRecoveryTimes?: boolean;
+    useParticipantMap?: boolean;
     usePublishState?: boolean;
     nextMatchUps?: boolean;
     inContext?: boolean;
 };
-declare function getCompetitionMatchUps({ scheduleVisibilityFilters, hydrateParticipants, participantsProfile, tournamentRecords, policyDefinitions, usePublishState, matchUpFilters, contextFilters, nextMatchUps, inContext, }: CompetitionMatchUpsArgs): ResultType & {
+declare function getCompetitionMatchUps({ scheduleVisibilityFilters, hydrateParticipants, participantsProfile, tournamentRecords, useParticipantMap, policyDefinitions, usePublishState, matchUpFilters, contextFilters, nextMatchUps, inContext, }: CompetitionMatchUpsArgs): ResultType & {
+    mappedParticipants?: {
+        [key: string]: HydratedParticipant;
+    };
     abandonedMatchUps?: HydratedMatchUp[];
     completedMatchUps?: HydratedMatchUp[];
     upcomingMatchUps?: HydratedMatchUp[];
@@ -6059,6 +6069,7 @@ declare function drawMatchUps({ participants: tournamentParticipants, tournament
     abandonedMatchUps?: HydratedMatchUp[] | undefined;
     completedMatchUps?: HydratedMatchUp[] | undefined;
     upcomingMatchUps?: HydratedMatchUp[] | undefined;
+    participants?: HydratedParticipant[] | undefined;
     pendingMatchUps?: HydratedMatchUp[] | undefined;
     byeMatchUps?: HydratedMatchUp[] | undefined;
     matchUpsMap?: MatchUpsMap | undefined;
@@ -7292,10 +7303,12 @@ type GetEventDataArgs = {
     policyDefinitions?: PolicyDefinitions;
     allParticipantResults?: boolean;
     sortConfig?: StructureSortConfig;
+    hydrateParticipants?: boolean;
     tournamentRecord: Tournament;
     usePublishState?: boolean;
     refreshResults?: boolean;
     pressureRating?: boolean;
+    contextProfile?: any;
     eventId?: string;
     status?: string;
     event?: Event$1;
@@ -8129,6 +8142,9 @@ type ProAutoScheduleArgs = {
     scheduledDate: string;
 };
 declare function proAutoSchedule({ scheduleCompletedMatchUps, tournamentRecords, scheduledDate, matchUps, }: ProAutoScheduleArgs): {
+    mappedParticipants?: {
+        [key: string]: HydratedParticipant;
+    } | undefined;
     completedMatchUps?: HydratedMatchUp[] | undefined;
     dateMatchUps?: HydratedMatchUp[] | undefined;
     courtPrefix?: string | undefined;
@@ -8151,6 +8167,9 @@ declare function proAutoSchedule({ scheduleCompletedMatchUps, tournamentRecords,
 } | {
     scheduled: HydratedMatchUp[];
     notScheduled: HydratedMatchUp[];
+    mappedParticipants?: {
+        [key: string]: HydratedParticipant;
+    } | undefined;
     completedMatchUps?: HydratedMatchUp[] | undefined;
     dateMatchUps?: HydratedMatchUp[] | undefined;
     courtPrefix?: string | undefined;

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.1.30';
+    return '2.2.1';
 }
 
 const SINGLES_MATCHUP = 'SINGLES';
@@ -7780,7 +7780,7 @@ const membershipMap = {
     [GROUP]: 'groups',
     [TEAM]: 'teams',
 };
-function getParticipantMap({ withIndividualParticipants, convertExtensions, tournamentRecord, withSignInStatus, withScaleValues, internalUse, withISO2, withIOC, }) {
+function getParticipantMap({ withIndividualParticipants, convertExtensions, tournamentRecord, withSignInStatus, withScaleValues, withGroupings, internalUse, withISO2, withIOC, }) {
     const missingParticipantIds = [];
     const participantMap = {};
     for (const participant of tournamentRecord.participants ?? []) {
@@ -7811,9 +7811,7 @@ function getParticipantMap({ withIndividualParticipants, convertExtensions, tour
             participantMap[participantId].participant.signedIn = signedIn(participantCopy);
         }
         if (withScaleValues) {
-            const { ratings, rankings, seedings } = getScaleValues({
-                participant: participantCopy,
-            });
+            const { ratings, rankings, seedings } = getScaleValues({ participant: participantCopy });
             participantMap[participantId].participant.seedings = seedings;
             participantMap[participantId].participant.rankings = rankings;
             participantMap[participantId].participant.ratings = ratings;
@@ -7829,7 +7827,15 @@ function getParticipantMap({ withIndividualParticipants, convertExtensions, tour
         const template = isObject(withIndividualParticipants) ? withIndividualParticipants : undefined;
         addIndividualParticipants({ participantMap, template });
     }
-    return { missingParticipantIds, participantMap };
+    let groupInfo;
+    if (withGroupings) {
+        groupInfo = addParticipantGroupings({
+            participants: Object.values(participantMap).map(({ participant }) => participant),
+            participantsProfile: { convertExtensions },
+            deepCopy: false,
+        }).groupInfo;
+    }
+    return { missingParticipantIds, participantMap, groupInfo };
 }
 function signedIn(participant) {
     const { timeItem } = getTimeItem({
@@ -7909,12 +7915,11 @@ function initializeParticipantId({ participantMap, participantId }) {
 
 function hydrateParticipants({ participantsProfile, useParticipantMap, tournamentRecord, contextProfile, inContext, }) {
     if (useParticipantMap) {
-        const participantMap = getParticipantMap({
+        return getParticipantMap({
             ...participantsProfile,
             ...contextProfile,
             tournamentRecord,
-        })?.participantMap;
-        return { participantMap };
+        });
     }
     let participants = makeDeepCopy(tournamentRecord.participants, false, true) || [];
     if (participantsProfile?.withIOC || participantsProfile?.withISO2)
@@ -10342,7 +10347,7 @@ function addMatchUpContext({ scheduleVisibilityFilters, sourceDrawPositionRanges
         });
         Object.assign(matchUpWithContext, makeDeepCopy({ sides }, true, true));
     }
-    if (tournamentParticipants && matchUpWithContext.sides && hydrateParticipants !== false) {
+    if (tournamentParticipants && matchUpWithContext.sides) {
         const participantAttributes = appliedPolicies?.[POLICY_TYPE_PARTICIPANT];
         const getMappedParticipant = (participantId) => {
             const participant = participantMap?.[participantId]?.participant;
@@ -10365,15 +10370,23 @@ function addMatchUpContext({ scheduleVisibilityFilters, sourceDrawPositionRanges
                         })
                         : undefined), undefined, true);
                 if (participant) {
+                    let entryStatus, entryStage;
                     if (drawDefinition?.entries) {
                         const entry = drawDefinition.entries.find((entry) => entry.participantId === side.participantId);
                         const eEntry = event?.entries?.find((entry) => entry.participantId === side.participantId);
-                        participant.entryStatus = entry?.entryStatus || eEntry?.entryStatus;
+                        entryStatus = entry?.entryStatus || eEntry?.entryStatus;
+                        participant.entryStatus = entryStatus;
                         if (entry?.entryStage) {
-                            participant.entryStage = entry.entryStage;
+                            entryStage = entry.entryStage;
+                            participant.entryStage = entryStage;
                         }
                     }
-                    Object.assign(side, { participant });
+                    if (hydrateParticipants !== false) {
+                        Object.assign(side, { participant });
+                    }
+                    else {
+                        Object.assign(side, { participant: { entryStage, entryStatus } });
+                    }
                 }
             }
             if (side?.participant?.individualParticipantIds?.length && !side.participant.individualParticipants?.length) {
@@ -10389,7 +10402,8 @@ function addMatchUpContext({ scheduleVisibilityFilters, sourceDrawPositionRanges
                             })
                             : undefined));
                 });
-                Object.assign(side.participant, { individualParticipants });
+                if (hydrateParticipants !== false)
+                    Object.assign(side.participant, { individualParticipants });
             }
         });
         if (!matchUpWithContext.matchUpType) {
@@ -10772,17 +10786,28 @@ function getAllStructureMatchUps(params) {
                 structureId,
             }).drawPositionsRanges
             : undefined;
+        let tournamentParticipants = params.tournamentParticipants;
+        let participantMap = params.participantMap;
+        if (!tournamentParticipants?.length && !participantMap && tournamentRecord) {
+            ({ participants: tournamentParticipants = [], participantMap } = hydrateParticipants({
+                participantsProfile: params.participantsProfile,
+                useParticipantMap: params.useParticipantMap,
+                policyDefinitions: params.policyDefinitions,
+                tournamentRecord,
+                contextProfile,
+                inContext,
+            }));
+        }
         matchUps = matchUps.map((matchUp) => {
             return addMatchUpContext({
-                tournamentParticipants: params.tournamentParticipants ?? tournamentRecord?.participants,
                 scheduleVisibilityFilters: params.scheduleVisibilityFilters,
                 hydrateParticipants: params.hydrateParticipants,
                 afterRecoveryTimes: params.afterRecoveryTimes,
                 usePublishState: params.usePublishState,
-                participantMap: params.participantMap,
                 scheduleTiming: params.scheduleTiming,
                 publishStatus: params.publishStatus,
                 sourceDrawPositionRanges,
+                tournamentParticipants,
                 positionAssignments,
                 drawPositionsRanges,
                 initialRoundOfPlay,
@@ -10791,6 +10816,7 @@ function getAllStructureMatchUps(params) {
                 appliedPolicies,
                 seedAssignments,
                 contextContent,
+                participantMap,
                 contextProfile,
                 drawDefinition,
                 scoringActive,
@@ -14395,16 +14421,10 @@ function getParticipants(params) {
         const template = isObject(withIndividualParticipants) ? withIndividualParticipants : undefined;
         for (const participant of filteredParticipants) {
             for (const individualParticipantId of participant.individualParticipantIds ?? []) {
-                const mappedParticipant = participantMap[participant.participantId].participant;
-                if (!mappedParticipant?.individualParticipants)
-                    mappedParticipant.individualParticipants = [];
-                if (!participant.individualParticipants) {
+                if (!participant.individualParticipants)
                     participant.individualParticipants = [];
-                }
                 const source = ppMap.get(individualParticipantId);
                 const individualParticipant = template ? attributeFilter({ template, source }) : source;
-                if (mappedParticipant?.individualParticipants)
-                    mappedParticipant.individualParticipants.push(individualParticipant);
                 participant.individualParticipants.push(individualParticipant);
             }
         }
@@ -17695,11 +17715,11 @@ function extractAttributeValues({ policyAttributes, idCollections, participants,
 }
 
 function getPositionedParticipants({ candidatePositionAssignments, participantsWithGroupings, policyAttributes, idCollections, }) {
-    const participantsMap = Object.assign({}, ...participantsWithGroupings.map((participant) => ({
+    const mappedParticipants = Object.assign({}, ...participantsWithGroupings.map((participant) => ({
         [participant.participantId]: participant,
     })));
     return candidatePositionAssignments.map((assignment) => {
-        const participant = participantsMap[assignment.participantId];
+        const participant = mappedParticipants[assignment.participantId];
         const { values } = extractAttributeValues({
             participants: participantsWithGroupings,
             policyAttributes,
@@ -34805,7 +34825,7 @@ const displayConstants = {
 };
 
 function getDrawData(params) {
-    const { tournamentParticipants = [], includePositionAssignments, policyDefinitions, tournamentRecord, inContext = true, usePublishState, status = PUBLIC, pressureRating, refreshResults, drawDefinition, noDeepCopy, sortConfig, context, event, } = params;
+    const { tournamentParticipants = [], includePositionAssignments, policyDefinitions, tournamentRecord, inContext = true, usePublishState, status = PUBLIC, pressureRating, refreshResults, contextProfile, drawDefinition, noDeepCopy, sortConfig, context, event, } = params;
     if (!drawDefinition)
         return { error: MISSING_DRAW_DEFINITION };
     const drawInfo = (({ matchUpFormat, updatedAt, drawType, drawName, drawId }) => ({
@@ -34859,11 +34879,14 @@ function getDrawData(params) {
             const { matchUps, roundMatchUps, roundProfile } = getAllStructureMatchUps({
                 seedAssignments: !structure?.seedAssignments?.length ? seedAssignments : undefined,
                 context: { drawId: drawInfo.drawId, ...context },
+                hydrateParticipants: params.hydrateParticipants,
+                participantsProfile: params.participantsProfile,
                 tournamentParticipants,
                 policyDefinitions,
                 tournamentRecord,
                 usePublishState,
                 publishStatus,
+                contextProfile,
                 drawDefinition,
                 inContext,
                 structure,
@@ -34975,7 +34998,7 @@ function getDrawData(params) {
 }
 
 function getEventData(params) {
-    const { includePositionAssignments, participantsProfile, policyDefinitions, usePublishState, status = PUBLIC, sortConfig, } = params;
+    const { includePositionAssignments, participantsProfile, policyDefinitions, usePublishState, status = PUBLIC, contextProfile, sortConfig, } = params;
     const paramsCheck = checkRequiredParameters(params, [
         { tournamentRecord: true },
         { [ANY_OF]: { event: false, eventId: false } },
@@ -35047,6 +35070,7 @@ function getEventData(params) {
             structures,
         }))(getDrawData({
             allParticipantResults: params.allParticipantResults,
+            hydrateParticipants: params.hydrateParticipants,
             context: { eventId, tournamentId, endDate },
             pressureRating: params.pressureRating,
             refreshResults: params.refreshResults,
@@ -35056,6 +35080,7 @@ function getEventData(params) {
             policyDefinitions,
             tournamentRecord,
             usePublishState,
+            contextProfile,
             drawDefinition,
             publishStatus,
             sortConfig,
@@ -36483,13 +36508,12 @@ function tournamentMatchUps(params) {
     if (!params?.tournamentRecord)
         return { error: MISSING_TOURNAMENT_RECORD };
     let contextContent = params.contextContent;
-    const { scheduleVisibilityFilters, participantsProfile, afterRecoveryTimes, policyDefinitions, useParticipantMap, tournamentRecord, inContext = true, usePublishState, contextFilters, matchUpFilters, contextProfile, nextMatchUps, context, } = params;
+    const { scheduleVisibilityFilters, participantsProfile, afterRecoveryTimes, policyDefinitions, tournamentRecord, inContext = true, usePublishState, contextFilters, matchUpFilters, contextProfile, nextMatchUps, context, } = params;
     const tournamentId = params.tournamentId ?? tournamentRecord.tournamentId;
     const events = tournamentRecord?.events ?? [];
     const { participants, participantMap, groupInfo } = hydrateParticipants({
         participantsProfile,
         policyDefinitions,
-        useParticipantMap,
         tournamentRecord,
         contextProfile,
         inContext,
@@ -36546,10 +36570,10 @@ function tournamentMatchUps(params) {
         });
         return matchUps;
     }, { matchUpsCount: 0 });
-    return { ...eventsDrawMatchUpsResult, groupInfo };
+    return { ...eventsDrawMatchUpsResult, groupInfo, participants };
 }
 
-function getCompetitionMatchUps({ scheduleVisibilityFilters, hydrateParticipants, participantsProfile, tournamentRecords, policyDefinitions, usePublishState, matchUpFilters, contextFilters, nextMatchUps, inContext, }) {
+function getCompetitionMatchUps({ scheduleVisibilityFilters, hydrateParticipants, participantsProfile, tournamentRecords, useParticipantMap, policyDefinitions, usePublishState, matchUpFilters, contextFilters, nextMatchUps, inContext, }) {
     if (typeof tournamentRecords !== 'object' || !Object.keys(tournamentRecords).length)
         return { error: MISSING_TOURNAMENT_RECORDS };
     const tournamentIds = Object.keys(tournamentRecords);
@@ -36559,6 +36583,7 @@ function getCompetitionMatchUps({ scheduleVisibilityFilters, hydrateParticipants
             scheduleVisibilityFilters,
             hydrateParticipants,
             participantsProfile,
+            useParticipantMap,
             policyDefinitions,
             tournamentRecord,
             usePublishState,
@@ -36568,22 +36593,28 @@ function getCompetitionMatchUps({ scheduleVisibilityFilters, hydrateParticipants
             inContext,
         });
     });
+    const mappedParticipants = {};
     const groupInfo = {};
     const competitionMatchUpsResult = tournamentsMatchUps.reduce((groupings, matchUpGroupings) => {
         const keys = Object.keys(matchUpGroupings);
         keys.forEach((key) => {
-            if (Array.isArray(matchUpGroupings[key])) {
+            if (key === 'groupInfo') {
+                Object.assign(groupInfo, matchUpGroupings[key]);
+            }
+            else if (key === 'participants') {
+                for (const participant of matchUpGroupings[key] ?? []) {
+                    mappedParticipants[participant.participantId] = participant;
+                }
+            }
+            else if (Array.isArray(matchUpGroupings[key])) {
                 if (!groupings[key])
                     groupings[key] = [];
                 groupings[key] = groupings[key].concat(matchUpGroupings[key]);
             }
-            if (key === 'groupInfo') {
-                Object.assign(groupInfo, matchUpGroupings[key]);
-            }
         });
         return groupings;
     }, {});
-    return { ...competitionMatchUpsResult, groupInfo };
+    return { ...competitionMatchUpsResult, groupInfo, mappedParticipants };
 }
 
 function competitionScheduleMatchUps(params) {
@@ -36671,7 +36702,7 @@ function competitionScheduleMatchUps(params) {
             params.matchUpFilters.excludeMatchUpStatuses = [COMPLETED$1];
         }
     }
-    const { completedMatchUps, upcomingMatchUps, pendingMatchUps, groupInfo } = getCompetitionMatchUps({
+    const { completedMatchUps, upcomingMatchUps, pendingMatchUps, groupInfo, mappedParticipants } = getCompetitionMatchUps({
         ...params,
         matchUpFilters: params.matchUpFilters,
         contextFilters: params.contextFilters,
@@ -36720,6 +36751,7 @@ function competitionScheduleMatchUps(params) {
     });
     const result = {
         completedMatchUps: alwaysReturnCompleted ? allCompletedMatchUps : completedMatchUps,
+        mappedParticipants: params.hydrateParticipants ? undefined : mappedParticipants,
         dateMatchUps,
         courtsData,
         groupInfo,
@@ -53556,7 +53588,7 @@ function getAvgWTN({ eventType, matchUps, eventId, drawId }) {
             matchUpFormatCounts[matchUpFormat] = 0;
         matchUpFormatCounts[matchUpFormat] += 1;
     };
-    const participantsMap = matchUps
+    const mappedParticipants = matchUps
         .filter((matchUp) => (eventId ? matchUp.eventId === eventId : matchUp.drawId === drawId))
         .reduce((participants, matchUp) => {
         countMatchUpFormat(matchUp);
@@ -53565,7 +53597,7 @@ function getAvgWTN({ eventType, matchUps, eventId, drawId }) {
             .forEach((participant) => (participants[participant.participantId] = participant));
         return participants;
     }, {});
-    const eventParticipants = Object.values(participantsMap);
+    const eventParticipants = Object.values(mappedParticipants);
     const wtnRatings = eventParticipants
         .map((participant) => getDetailsWTN({ participant, eventType }))
         .filter(({ wtnRating }) => wtnRating);