tods-competition-factory 2.1.6 → 2.1.8

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

@@ -4961,7 +4961,8 @@ declare function generateStatCrew(params: any): (ResultType & {
     valid?: boolean | undefined;
 }) | {
     success: boolean;
-    xml: any;
+    json: any[];
+    xml: string[];
 };
 
 type GenerateLineUpsArgs = {
@@ -7903,7 +7904,7 @@ type GetStructureReportsArgs = {
     extensionProfiles?: any[];
     firstFlightOnly?: boolean;
 };
-declare function getStructureReports({ firstFlightOnly, extensionProfiles, tournamentRecord, }: GetStructureReportsArgs): {
+declare function getStructureReports(params: GetStructureReportsArgs): {
     error: {
         message: string;
         code: string;

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.1.6';
+    return '2.1.8';
 }
 
 function isFunction(obj) {
@@ -1682,10 +1682,11 @@ function getProvider() {
 function handleCaughtError({ engineName, methodName, params, err }) {
     const caughtErrorHandler = (isFunction(_globalStateProvider.handleCaughtError) && _globalStateProvider.handleCaughtError) ||
         syncGlobalState$1.handleCaughtError;
+    const { tournamentRecord, ...rest } = params;
     return caughtErrorHandler({
+        params: rest,
         engineName,
         methodName,
-        params,
         err,
     });
 }
@@ -14786,8 +14787,8 @@ function assignMatchUpDrawPosition({ inContextDrawMatchUps, sourceMatchUpStatus,
     const matchUp = matchUpsMap?.drawMatchUps?.find((matchUp) => matchUp.matchUpId === matchUpId);
     const drawPositions = matchUp?.drawPositions ?? [];
     const { positionAdded, positionAssigned, updatedDrawPositions } = getUpdatedDrawPositions({
-        drawPosition,
         drawPositions,
+        drawPosition,
     });
     const { positionAssignments } = getPositionAssignments$1({
         drawDefinition,
@@ -38992,7 +38993,7 @@ function setEventDates(params) {
             endDate: false,
         },
         {
-            [VALIDATE]: (value) => value.every((d) => dateValidation.test(d)),
+            [VALIDATE]: (value) => value.filter(Boolean).every((d) => dateValidation.test(d)),
             [INVALID]: INVALID_DATE,
             activeDates: false,
         },
@@ -39003,7 +39004,8 @@ function setEventDates(params) {
     ]);
     if (paramsCheck.error)
         return paramsCheck;
-    const { tournamentRecord, activeDates, weekdays, event, startDate, endDate } = params;
+    const { tournamentRecord, weekdays, event, startDate, endDate } = params;
+    const activeDates = params.activeDates?.filter(Boolean);
     if (startDate && endDate) {
         const newStartDate = new Date(extractDate(startDate)).getTime();
         const newEndDate = new Date(extractDate(endDate)).getTime();
@@ -40223,7 +40225,66 @@ function generateStatCrew(params) {
         return paramsCheck;
     const { tournamentRecord } = params;
     const { startDate, tournamentId, tournamentName } = tournamentRecord;
+    const { participantMap, matchUps, mappedMatchUps } = getParticipants({
+        withMatchUps: true,
+        withEvents: true,
+        tournamentRecord,
+    });
     const teamParticipants = tournamentRecord.participants.filter((participant) => participant.participantType === TEAM);
+    const teamMatchUps = matchUps?.filter((matchUp) => matchUp.matchUpType === TEAM) ?? [];
+    const tieMatchUps = teamMatchUps?.reduce((t, matchUp) => {
+        const tieMatchUps = matchUp?.tieMatchUps ?? [];
+        return tieMatchUps ? [...t, ...tieMatchUps] : tieMatchUps;
+    }, []) ?? [];
+    const singles = matchUps?.filter((matchUp) => matchUp.matchUpType === SINGLES) ?? [];
+    const doubles = matchUps?.filter((matchUp) => matchUp.matchUpType === DOUBLES) ?? [];
+    const allDuals = tieMatchUps.length === singles.length + doubles.length;
+    const isDual = teamMatchUps.length === 1 && allDuals;
+    const tournament = !allDuals ? 'Y' : 'N';
+    const attrs = {
+        mappedMatchUps,
+        participantMap,
+        tournamentName,
+        tournamentId,
+        tournament,
+        startDate,
+    };
+    const xmlResult = [];
+    const jsonResult = [];
+    if (isDual) {
+        const teamMatchUp = teamMatchUps[0];
+        const { json, xml } = getXml({
+            teamParticipants,
+            teamMatchUp,
+            ...attrs,
+            doubles,
+            singles,
+        });
+        jsonResult.push(json);
+        xmlResult.push(xml);
+    }
+    else {
+        for (const teamMatchUp of teamMatchUps) {
+            const teamParticipantIds = teamMatchUp?.sides
+                ?.map(({ participant }) => participant?.participantId)
+                .filter(Boolean);
+            if (teamParticipantIds?.length !== 2)
+                continue;
+            const teamParticipants = teamParticipantIds.map((participantId) => participantId && participantMap?.[participantId]?.participant);
+            const { xml, json } = getXml({
+                doubles: teamMatchUp.tieMatchUps?.filter((matchUp) => matchUp.matchUpType === DOUBLES),
+                singles: teamMatchUp.tieMatchUps?.filter((matchUp) => matchUp.matchUpType === SINGLES),
+                teamParticipants,
+                teamMatchUp,
+                ...attrs,
+            });
+            jsonResult.push(json);
+            xmlResult.push(xml);
+        }
+    }
+    return { json: jsonResult, xml: xmlResult, ...SUCCESS };
+}
+function getXml({ teamParticipants, mappedMatchUps, participantMap, tournamentName, tournamentId, teamMatchUp, tournament, startDate, doubles, singles, }) {
     const homeTeam = teamParticipants?.find((team) => team.participantRoleResponsibilities?.includes('Home'));
     const awayTeams = teamParticipants?.filter((team) => team.participantId !== homeTeam?.participantId);
     const date = formatDate(startDate, '/', 'MDY');
@@ -40231,51 +40292,17 @@ function generateStatCrew(params) {
     const homeid = homeTeam?.participantId || awayTeams?.[1]?.participantId;
     const visname = awayTeams?.[0]?.participantName;
     const visid = awayTeams?.[0]?.participantId;
-    const matchUps = allTournamentMatchUps({ tournamentRecord }).matchUps;
-    const singles = matchUps?.filter((matchUp) => matchUp.matchUpType === SINGLES);
-    const doubles = matchUps?.filter((matchUp) => matchUp.matchUpType === DOUBLES);
-    const getScoreAttributes = ({ sets, sideNumber }) => Object.assign({}, ...(sets?.map((set) => {
-        const { setNumber, side1Score, side2Score, side1TiebreakScore, side2TiebreakScore } = set;
-        const setKey = `set_${setNumber}`;
-        const tbKey = `tie_${setNumber}`;
-        const setValue = sideNumber === 1 ? side1Score : side2Score;
-        const tieValue = sideNumber === 1 ? side1TiebreakScore : side2TiebreakScore;
-        return { [setKey]: setValue, [tbKey]: tieValue };
-    }) ?? []));
-    const getParticipantAttibutes = ({ participant }) => {
-        const pair = participant.individualParticipants?.length === 2;
-        const pairTeamParticipantIds = pair
-            ? unique(participant.individualParticipants?.map((p) => p.teams?.[0]?.participantId))
-            : [];
-        const pairTeamIds = pair ? unique(participant.individualParticipants?.map((p) => p.teams?.[0]?.teamId)) : [];
-        const teamParticipantId = (!pair && participant.teams?.[0]?.participantId) ||
-            (pairTeamParticipantIds?.length === 1 && pairTeamParticipantIds[0]) ||
-            undefined;
-        const team = (!pair && participant.teams?.[0]?.teamId) || (pairTeamIds?.length === 1 && pairTeamIds[0]) || teamParticipantId;
-        const name = !pair ? participant.participantName : undefined;
-        const name_1 = participant.individualParticipants?.[0]?.participantName;
-        const name_2 = participant.individualParticipants?.[1]?.participantName;
-        const vh = (homeid && (teamParticipantId === homeid ? 'H' : 'V')) || '';
-        return definedAttributes({ vh, team, name, name_1, name_2 });
-    };
-    const mapMatchUp = (matchUp) => {
-        const { collectionPosition: match, orderOfFinish: order, matchUpType, sides } = matchUp;
-        const childArray = sides?.map((side) => {
-            const { sideNumber, participant } = side;
-            const scoreAttributes = getScoreAttributes({ sets: matchUp.score?.sets, sideNumber });
-            const scoreType = matchUpType === SINGLES ? 'singles_score' : 'doubles_score';
-            return { [scoreType]: { ...getParticipantAttibutes({ participant }), ...scoreAttributes } };
-        });
-        const matchType = matchUpType === SINGLES ? 'singles_match' : 'doubles_match';
-        return { [matchType]: { match, order, childArray } };
-    };
-    const json = {
+    const uniValues = {};
+    const teams = teamParticipants.map((teamParticipant) => ({
+        team: { ...getTeam({ teamParticipant, teamMatchUp, uniValues, participantMap, mappedMatchUps, homeid }) },
+    }));
+    const json = definedAttributes({
         venue: {
-            tournament: teamParticipants?.length > 2 ? 'Y' : 'N',
+            tournamentname: tournament ? tournamentName : undefined,
             neutralgame: !homeTeam ? 'Y' : 'N',
-            tournamentname: tournamentName,
             gameid: tournamentId,
             officials: {},
+            tournament,
             rules: {},
             homename,
             visname,
@@ -40283,11 +40310,108 @@ function generateStatCrew(params) {
             visid,
             date,
         },
-        singles_matches: singles?.map(mapMatchUp),
-        doubles_matches: doubles?.map(mapMatchUp),
-    };
-    const xml = jsonToXml({ json, tagName: 'tngame' });
-    return { xml, ...SUCCESS };
+        childArray: teams,
+        singles_matches: singles?.map((matchUp) => mapMatchUp({ matchUp, homeid, uniValues })),
+        doubles_matches: doubles?.map((matchUp) => mapMatchUp({ matchUp, homeid, uniValues })),
+    });
+    return { json, xml: jsonToXml({ json, tagName: 'tngame' }) };
+}
+function getParticipantAttibutes({ homeid, uniValues, participant }) {
+    if (!participant)
+        return {};
+    const pair = participant.individualParticipants?.length === 2;
+    const pairTeamParticipantIds = pair
+        ? unique(participant.individualParticipants?.map((p) => p.teams?.[0]?.participantId))
+        : [];
+    const pairTeamIds = pair ? unique(participant.individualParticipants?.map((p) => p.teams?.[0]?.teamId)) : [];
+    const teamParticipantId = (!pair && participant.teams?.[0]?.participantId) ||
+        (pairTeamParticipantIds?.length === 1 && pairTeamParticipantIds[0]) ||
+        undefined;
+    const team = (!pair && participant.teams?.[0]?.teamId) || (pairTeamIds?.length === 1 && pairTeamIds[0]) || teamParticipantId;
+    const name = !pair ? participant.participantName : undefined;
+    const name_1 = participant.individualParticipants?.[0]?.participantName;
+    const name_2 = participant.individualParticipants?.[1]?.participantName;
+    const vh = (homeid && (teamParticipantId === homeid ? 'H' : 'V')) || '';
+    const uni = !pair ? uniValues[teamParticipantId][participant.participantId] : undefined;
+    const uni_1 = uniValues[teamParticipantId][participant.individualParticipants?.[0]?.participantId];
+    const uni_2 = uniValues[teamParticipantId][participant.individualParticipants?.[1]?.participantId];
+    return definedAttributes({ vh, uni, uni_1, uni_2, team, name, name_1, name_2 });
+}
+function getScoreAttributes({ sets, sideNumber }) {
+    return Object.assign({}, ...(sets?.map((set) => {
+        const { setNumber, side1Score, side2Score, side1TiebreakScore, side2TiebreakScore } = set;
+        const setKey = `set_${setNumber}`;
+        const tbKey = `tie_${setNumber}`;
+        const setValue = sideNumber === 1 ? side1Score : side2Score;
+        const tieValue = sideNumber === 1 ? side1TiebreakScore : side2TiebreakScore;
+        return { [setKey]: setValue, [tbKey]: tieValue };
+    }) ?? []));
+}
+function getTeam({ teamParticipant, teamMatchUp, participantMap, mappedMatchUps, homeid, uniValues }) {
+    const { participantId: id, participantName: name } = teamParticipant;
+    const vh = (homeid && (id === homeid ? 'H' : 'V')) || '';
+    const teamMatchUps = participantMap?.[id]?.matchUps;
+    const matchUpIds = teamMatchUps && Object.keys(teamMatchUps);
+    const teamSideNumber = teamMatchUp?.sides?.find(({ participant }) => participant.participantId === id)?.sideNumber;
+    const setScore = teamMatchUp?.score?.sets?.[0]?.[`side${teamSideNumber}Score`] ?? 0;
+    uniValues[id] = {};
+    const winLoss = { SINGLES: { w: 0, l: 0 }, DOUBLES: { w: 0, l: 0 } };
+    const doubles = [];
+    const singles = [];
+    let calcScore = 0;
+    for (const matchUpId of matchUpIds ?? []) {
+        const matchUp = mappedMatchUps?.[matchUpId];
+        const sideNumber = matchUp.sides.find(({ participant }) => participant.participantId === id)?.sideNumber;
+        const matchScore = matchUp.score?.sets?.[0]?.[`side${sideNumber}Score`] ?? 0;
+        calcScore += matchScore;
+        for (const tieMatchUp of matchUp.tieMatchUps ?? []) {
+            const { matchUpType, winningSide } = tieMatchUp;
+            const wl = (winningSide && (winningSide === sideNumber ? 'w' : 'l')) || '';
+            if (wl)
+                winLoss[matchUpType][wl] += 1;
+            const won = wl === 'w' ? '1' : '0';
+            const lost = wl === 'l' ? '1' : '0';
+            if (matchUpType === SINGLES) {
+                const pair = singles.length + 1;
+                singles.push({ singles_pair: { pair, won, lost, tied: '0' } });
+            }
+            else if (matchUpType === DOUBLES) {
+                const pair = doubles.length + 1;
+                doubles.push({ doubles_pair: { pair, won, lost, tied: '0' } });
+            }
+        }
+    }
+    const totals = [
+        { singles: { childArray: singles, won: winLoss.SINGLES.w, lost: winLoss.SINGLES.l } },
+        { doubles: { childArray: doubles, won: winLoss.DOUBLES.w, lost: winLoss.DOUBLES.l } },
+    ];
+    const players = [];
+    let playerIndex = 1;
+    for (const individualParticipantId of teamParticipant.individualParticipantIds) {
+        const mappedParticipant = participantMap?.[individualParticipantId];
+        if (mappedParticipant) {
+            const { participant, counters } = mappedParticipant;
+            const doublesStats = { won: counters?.DOUBLES?.wins || 0, lost: counters?.DOUBLES?.losses || 0 };
+            const singlesStats = { won: counters?.SINGLES?.wins || 0, lost: counters?.SINGLES?.losses || 0 };
+            const { participantName: name, participantId } = participant;
+            uniValues[id][participantId] = playerIndex;
+            players.push({ player: { name, uni: playerIndex, singles: singlesStats, doubles: doublesStats } });
+        }
+        playerIndex += 1;
+    }
+    const score = setScore || calcScore;
+    return { vh, id, name, score, totals, childArray: players };
+}
+function mapMatchUp({ matchUp, homeid, uniValues }) {
+    const { collectionPosition: match, orderOfFinish: order, matchUpType, sides } = matchUp ?? {};
+    const childArray = sides?.map((side) => {
+        const { sideNumber, participant } = side;
+        const scoreAttributes = getScoreAttributes({ sets: matchUp.score?.sets, sideNumber });
+        const scoreType = matchUpType === SINGLES ? 'singles_score' : 'doubles_score';
+        return { [scoreType]: { ...getParticipantAttibutes({ homeid, uniValues, participant }), ...scoreAttributes } };
+    });
+    const matchType = matchUpType === SINGLES ? 'singles_match' : 'doubles_match';
+    return { [matchType]: { match, order, childArray } };
 }
 
 const ASC = 'ASC';
@@ -42417,6 +42541,8 @@ function doubleExitAdvancement(params) {
         return decorateResult({ result: { ...SUCCESS }, stack });
     const { matchUp: sourceMatchUp, targetMatchUps, targetLinks } = targetData;
     const { loserMatchUp, winnerMatchUp, loserTargetDrawPosition } = targetMatchUps;
+    const loserMatchUpIsEmptyExit = [WALKOVER$2, DEFAULTED].includes(loserMatchUp?.matchUpStatus) &&
+        !loserMatchUp.sides?.map((side) => side.participantId ?? side.participant).filter(Boolean).length;
     if (loserMatchUp && loserMatchUp.matchUpStatus !== BYE) {
         const { loserTargetLink } = targetLinks;
         if (appliedPolicies?.progression?.doubleExitPropagateBye) {
@@ -42432,7 +42558,7 @@ function doubleExitAdvancement(params) {
             if (result.error)
                 return decorateResult({ result, stack });
         }
-        else {
+        else if (!loserMatchUpIsEmptyExit) {
             const { feedRound, drawPositions, matchUpId } = loserMatchUp;
             const walkoverWinningSide = feedRound ? 2 : 2 - drawPositions.indexOf(loserTargetDrawPosition);
             const result = conditionallyAdvanceDrawPosition({
@@ -43035,6 +43161,19 @@ function removeDoubleExit(params) {
         });
     }
     const byePropagatedToLoserMatchUp = loserMatchUp?.matchUpStatus === BYE && (loserMatchUp?.feedRound || loserMatchUp?.roundNumber === 1);
+    const isFMLC = targetData?.targetLinks?.loserTargetLink?.linkCondition === FIRST_MATCHUP;
+    if (byePropagatedToLoserMatchUp && isFMLC) {
+        const roundMatchUps = inContextDrawMatchUps.filter(({ roundNumber, structureId }) => structureId === matchUp.structureId && roundNumber === 1);
+        const roundPositions = roundMatchUps.map(({ roundPosition }) => roundPosition);
+        const pairedPosition = chunkArray(roundPositions.sort(), 2)
+            .find((chunk) => chunk.includes(matchUp.roundPosition))
+            .filter((position) => position !== matchUp.roundPosition)[0];
+        const pairedMatchUpStatus = roundMatchUps.find(({ roundPosition }) => roundPosition === pairedPosition)?.matchUpStatus;
+        const pairedMatchUpIsDoubleExit = [DOUBLE_DEFAULT, DOUBLE_WALKOVER].includes(pairedMatchUpStatus);
+        if (pairedMatchUpIsDoubleExit) {
+            return decorateResult({ result: { ...SUCCESS }, stack });
+        }
+    }
     if (loserMatchUp && (loserMatchUp.matchUpStatus !== BYE || byePropagatedToLoserMatchUp)) {
         const inContextLoserMatchUp = inContextDrawMatchUps.find(({ matchUpId }) => matchUpId === loserMatchUp.matchUpId);
         const { structure: loserStructure } = findStructure({
@@ -52832,7 +52971,8 @@ function getAvgWTN({ eventType, matchUps, eventId, drawId }) {
     };
 }
 
-function getStructureReports({ firstFlightOnly = true, extensionProfiles, tournamentRecord, }) {
+function getStructureReports(params) {
+    const { tournamentRecord, extensionProfiles, firstFlightOnly } = params;
     if (!tournamentRecord)
         return { error: MISSING_TOURNAMENT_ID };
     const mainStructures = [];
@@ -52879,7 +53019,7 @@ function getStructureReports({ firstFlightOnly = true, extensionProfiles, tourna
         const drawDeletionsExtension = extensions?.find((x) => x.name === DRAW_DELETIONS);
         const drawDeletionsTimeItem = eventTimeItems?.find((x) => x.itemType === DRAW_DELETIONS);
         const drawDeletionsCount = drawDeletionsExtension?.value?.length || drawDeletionsTimeItem?.itemValue || 0;
-        const mapValues = Object.values(flightMap);
+        const mapValues = Object.values(flightMap ?? {});
         const minFlightNumber = flightMap && Math.min(...mapValues);
         const eventSeedingBasis = getSeedingBasis(eventTimeItems);
         eventStructureReports[eventId] = {
@@ -56184,7 +56324,8 @@ function updateCourtAvailability({ tournamentRecord }) {
 }
 
 function setTournamentDates(params) {
-    const { tournamentRecord, startDate, endDate, activeDates, weekdays } = params;
+    const { tournamentRecord, startDate, endDate, weekdays } = params;
+    const activeDates = params.activeDates?.filter(Boolean);
     const paramsCheck = checkRequiredParameters(params, [
         { tournamentRecord: true },
         {
@@ -56194,7 +56335,7 @@ function setTournamentDates(params) {
             endDate: false,
         },
         {
-            [VALIDATE]: (value) => value.every((d) => dateValidation.test(d)),
+            [VALIDATE]: (value) => value.filter(Boolean).every((d) => dateValidation.test(d)),
             [INVALID]: INVALID_DATE,
             activeDates: false,
         },
@@ -56209,7 +56350,7 @@ function setTournamentDates(params) {
         return { error: INVALID_VALUES };
     if (endDate && startDate && new Date(startDate) > new Date(endDate))
         return { error: INVALID_VALUES };
-    if (activeDates) {
+    if (activeDates?.length) {
         const start = startDate || tournamentRecord.startDate;
         const end = endDate || tournamentRecord.endDate;
         const validStart = !start || activeDates.every((d) => new Date(d) >= new Date(start));