tods-competition-factory 2.1.5 → 2.1.7

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.1.5';
+    return '2.1.7';
 }
 
 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,
     });
 }
@@ -10439,7 +10440,7 @@ const logColors = {
 
 const globalLog = [];
 function pushGlobalLog(value, devContextOverride) {
-    if (typeof value === 'string')
+    if (isString(value))
         value = { method: value };
     if (devContextOverride || getDevContext())
         globalLog.push(value);
@@ -40222,19 +40223,76 @@ function generateStatCrew(params) {
     if (paramsCheck.error)
         return paramsCheck;
     const { tournamentRecord } = params;
-    const { startDate, tournamentId } = tournamentRecord;
+    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 homeTeam = teamParticipants?.find((team) => team.participantRoleResponsibilities?.includes('Home'));
     const awayTeams = teamParticipants?.filter((team) => team.participantId !== homeTeam?.participantId);
     const date = formatDate(startDate, '/', 'MDY');
-    const neutralGame = !homeTeam ? 'Y' : 'N';
     const homename = homeTeam?.participantName || awayTeams?.[1]?.participantName;
     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 uniValues = {};
+    const getTeam = (teamParticipant) => {
+        const { participantId: id, participantName: name } = teamParticipant;
+        const vh = (homeid && (id === homeid ? 'H' : 'V')) || '';
+        const teamMatchUps = participantMap?.[id]?.matchUps;
+        const matchUpIds = teamMatchUps && Object.keys(teamMatchUps);
+        uniValues[id] = {};
+        const winLoss = { SINGLES: { w: 0, l: 0 }, DOUBLES: { w: 0, l: 0 } };
+        const doubles = [];
+        const singles = [];
+        let score = 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;
+            score += 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 } });
+                }
+                else if (matchUpType === DOUBLES) {
+                    const pair = doubles.length + 1;
+                    doubles.push({ doubles_pair: { pair, won, lost } });
+                }
+            }
+        }
+        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;
+        }
+        return { vh, id, name, score, totals, childArray: players };
+    };
+    const teams = teamParticipants.map((p) => ({ team: { ...getTeam(p) } }));
     const getScoreAttributes = ({ sets, sideNumber }) => Object.assign({}, ...(sets?.map((set) => {
         const { setNumber, side1Score, side2Score, side1TiebreakScore, side2TiebreakScore } = set;
         const setKey = `set_${setNumber}`;
@@ -40243,26 +40301,53 @@ function generateStatCrew(params) {
         const tieValue = sideNumber === 1 ? side1TiebreakScore : side2TiebreakScore;
         return { [setKey]: setValue, [tbKey]: tieValue };
     }) ?? []));
-    const getParticipantAttibutes = ({ matchUpId, participant }) => {
-        const name = !participant.individualParticipants ? participant.participantName : undefined;
+    const getParticipantAttibutes = ({ 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 = matchUpId === homeid ? 'H' : 'V';
-        return definedAttributes({ vh, name, name_1, name_2 });
+        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 });
     };
     const mapMatchUp = (matchUp) => {
-        const { collectionPosition: match, orderOfFinish: order, matchUpId, matchUpType, sides } = 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({ matchUpId, participant }), ...scoreAttributes } };
+            return { [scoreType]: { ...getParticipantAttibutes({ participant }), ...scoreAttributes } };
         });
         const matchType = matchUpType === SINGLES ? 'singles_match' : 'doubles_match';
         return { [matchType]: { match, order, childArray } };
     };
     const json = {
-        venue: { gameid: tournamentId, date, neutralGame, homeid, homename, visid, visname, officials: {}, rules: {} },
+        venue: {
+            tournament: teamParticipants?.length > 2 ? 'Y' : 'N',
+            neutralgame: !homeTeam ? 'Y' : 'N',
+            tournamentname: tournamentName,
+            gameid: tournamentId,
+            officials: {},
+            rules: {},
+            homename,
+            visname,
+            homeid,
+            visid,
+            date,
+        },
+        childArray: teams,
         singles_matches: singles?.map(mapMatchUp),
         doubles_matches: doubles?.map(mapMatchUp),
     };
@@ -42326,7 +42411,13 @@ function removeDirectedLoser({ sourceMatchUpStatus, loserParticipantId, tourname
 }
 function removeDirectedBye({ inContextDrawMatchUps, tournamentRecord, drawDefinition, drawPosition, matchUpsMap, targetLink, event, }) {
     const structureId = targetLink.target.structureId;
-    clearDrawPosition({
+    const stack = 'removeDirectedBye';
+    pushGlobalLog({
+        color: 'brightyellow',
+        method: stack,
+        drawPosition,
+    });
+    const result = clearDrawPosition({
         inContextDrawMatchUps,
         tournamentRecord,
         drawDefinition,
@@ -42335,7 +42426,7 @@ function removeDirectedBye({ inContextDrawMatchUps, tournamentRecord, drawDefini
         structureId,
         event,
     });
-    return { ...SUCCESS };
+    return decorateResult({ result, stack });
 }
 
 function lastSetFormatIsTimed(inContextMatchUp) {
@@ -42979,24 +43070,27 @@ const keyColors = {
 };
 function removeDoubleExit(params) {
     const { inContextDrawMatchUps, appliedPolicies, drawDefinition, matchUpsMap, targetData, matchUp } = params;
+    const { matchUpId } = matchUp;
     let { iteration = 0 } = params;
     iteration += 1;
     const stack = 'removeDoubleExit';
     pushGlobalLog({
-        method: stack,
         color: 'brightyellow',
+        method: stack,
+        matchUpId,
         iteration,
         keyColors,
     });
-    const { targetLinks: { loserTargetLink }, targetMatchUps: { loserMatchUp, winnerMatchUp, loserTargetDrawPosition }, } = targetData;
+    const { targetMatchUps: { loserMatchUp, winnerMatchUp, loserTargetDrawPosition }, targetLinks: { loserTargetLink }, } = targetData;
     if (winnerMatchUp && winnerMatchUp.matchUpStatus !== BYE) {
-        const { stage, roundNumber, roundPosition } = winnerMatchUp;
+        const { stage, roundNumber, roundPosition, structureName } = winnerMatchUp;
         pushGlobalLog({
             winner: 'winner',
-            stage,
-            roundNumber,
             roundPosition,
+            structureName,
+            roundNumber,
             keyColors,
+            stage,
         });
         conditionallyRemoveDrawPosition({
             ...params,
@@ -43005,22 +43099,24 @@ function removeDoubleExit(params) {
             iteration,
         });
     }
-    if (loserMatchUp && loserMatchUp.matchUpStatus !== BYE) {
+    const byePropagatedToLoserMatchUp = loserMatchUp?.matchUpStatus === BYE && (loserMatchUp?.feedRound || loserMatchUp?.roundNumber === 1);
+    if (loserMatchUp && (loserMatchUp.matchUpStatus !== BYE || byePropagatedToLoserMatchUp)) {
         const inContextLoserMatchUp = inContextDrawMatchUps.find(({ matchUpId }) => matchUpId === loserMatchUp.matchUpId);
         const { structure: loserStructure } = findStructure({
             drawDefinition,
             structureId: inContextLoserMatchUp.structureId,
         });
-        const { stage, roundNumber, roundPosition, feedRound } = loserMatchUp;
+        const { stage, roundNumber, roundPosition, feedRound, structureName } = loserMatchUp;
         pushGlobalLog({
             loser: 'loser',
-            stage,
-            roundNumber,
             roundPosition,
+            structureName,
+            roundNumber,
             keyColors,
             feedRound,
+            stage,
         });
-        if (appliedPolicies?.progression?.doubleExitPropagateBye) {
+        if (appliedPolicies?.progression?.doubleExitPropagateBye || byePropagatedToLoserMatchUp) {
             removeDirectedBye({
                 drawPosition: loserTargetDrawPosition,
                 targetLink: loserTargetLink,
@@ -43032,8 +43128,8 @@ function removeDoubleExit(params) {
         else {
             const result = conditionallyRemoveDrawPosition({
                 ...params,
-                structure: loserStructure,
                 targetMatchUp: loserMatchUp,
+                structure: loserStructure,
                 iteration,
             });
             if (result.error)
@@ -43045,7 +43141,7 @@ function removeDoubleExit(params) {
 function conditionallyRemoveDrawPosition(params) {
     const { inContextDrawMatchUps, appliedPolicies, drawDefinition, sourceMatchUp, targetMatchUp, matchUpsMap, structure, iteration, } = params;
     const stack = 'conditionallyRemoveDrawPosition';
-    pushGlobalLog({ method: stack });
+    pushGlobalLog({ method: stack, structureName: structure?.structureName, iteration });
     const nextTargetData = positionTargets({
         matchUpId: targetMatchUp.matchUpId,
         inContextDrawMatchUps,
@@ -43085,15 +43181,16 @@ function conditionallyRemoveDrawPosition(params) {
         }
     }
     if (nextWinnerMatchUp && drawPositionToRemove) {
-        const { stage, roundNumber, roundPosition } = nextWinnerMatchUp;
+        const { stage, roundNumber, roundPosition, structureName } = nextWinnerMatchUp;
         pushGlobalLog({
             method: 'removeDirectedWinner',
             drawPositionToRemove,
-            keyColors,
             color: 'brightgreen',
-            stage,
-            roundNumber,
             roundPosition,
+            structureName,
+            roundNumber,
+            keyColors,
+            stage,
         });
         removeDirectedWinner({
             winningDrawPosition: drawPositionToRemove,