tods-competition-factory 2.1.4 → 2.1.6

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

@@ -2679,13 +2679,6 @@ declare function luckyLoserDrawPositionAssignment(params: any): ResultType | {
     };
 };
 
-declare function alternateDrawPositionAssignment(params: any): ResultType | {
-    error: {
-        message: string;
-        code: string;
-    };
-};
-
 type ShiftRoundsArgs = {
     drawDefinition: DrawDefinition;
     targetRoundNumber: number;
@@ -2718,6 +2711,19 @@ declare function qualifierDrawPositionAssignment(params: any): ResultType | {
     };
 };
 
+declare function alternateDrawPositionAssignment({ alternateParticipantId, tournamentRecord, drawDefinition, drawPosition, structureId, }: {
+    alternateParticipantId: any;
+    tournamentRecord: any;
+    drawDefinition: any;
+    drawPosition: any;
+    structureId: any;
+}): ResultType | {
+    error: {
+        message: string;
+        code: string;
+    };
+};
+
 declare function removeDrawPositionAssignment(params: any): ResultType & {
     participantId?: string;
 };
@@ -4951,6 +4957,13 @@ declare function generateFlightProfile(params: GenerateFlightProfileArgs): {
     error?: ErrorType;
 };
 
+declare function generateStatCrew(params: any): (ResultType & {
+    valid?: boolean | undefined;
+}) | {
+    success: boolean;
+    xml: any;
+};
+
 type GenerateLineUpsArgs = {
     useDefaultEventRanking?: boolean;
     tournamentRecord: Tournament;
@@ -5048,10 +5061,11 @@ declare const index$g_generateFlightProfile: typeof generateFlightProfile;
 declare const index$g_generateLineUps: typeof generateLineUps;
 declare const index$g_generateQualifyingStructure: typeof generateQualifyingStructure;
 declare const index$g_generateSeedingScaleItems: typeof generateSeedingScaleItems;
+declare const index$g_generateStatCrew: typeof generateStatCrew;
 declare const index$g_generateVoluntaryConsolation: typeof generateVoluntaryConsolation;
 declare const index$g_roundRobinGroups: typeof roundRobinGroups;
 declare namespace index$g {
-  export { index$g_drawMatic as drawMatic, garman$1 as garman, index$g_generateAdHocMatchUps as generateAdHocMatchUps, index$g_generateAdHocRounds as generateAdHocRounds, index$g_generateAndPopulatePlayoffStructures as generateAndPopulatePlayoffStructures, index$g_generateCourts as generateCourts, index$g_generateDrawDefinition as generateDrawDefinition, index$g_generateDrawMaticRound as generateDrawMaticRound, index$g_generateDrawStructuresAndLinks as generateDrawStructuresAndLinks, index$g_generateDrawTypeAndModifyDrawDefinition as generateDrawTypeAndModifyDrawDefinition, index$g_generateFlightProfile as generateFlightProfile, index$g_generateLineUps as generateLineUps, index$g_generateQualifyingStructure as generateQualifyingStructure, index$g_generateSeedingScaleItems as generateSeedingScaleItems, index$g_generateVoluntaryConsolation as generateVoluntaryConsolation, index$g_roundRobinGroups as roundRobinGroups };
+  export { index$g_drawMatic as drawMatic, garman$1 as garman, index$g_generateAdHocMatchUps as generateAdHocMatchUps, index$g_generateAdHocRounds as generateAdHocRounds, index$g_generateAndPopulatePlayoffStructures as generateAndPopulatePlayoffStructures, index$g_generateCourts as generateCourts, index$g_generateDrawDefinition as generateDrawDefinition, index$g_generateDrawMaticRound as generateDrawMaticRound, index$g_generateDrawStructuresAndLinks as generateDrawStructuresAndLinks, index$g_generateDrawTypeAndModifyDrawDefinition as generateDrawTypeAndModifyDrawDefinition, index$g_generateFlightProfile as generateFlightProfile, index$g_generateLineUps as generateLineUps, index$g_generateQualifyingStructure as generateQualifyingStructure, index$g_generateSeedingScaleItems as generateSeedingScaleItems, index$g_generateStatCrew as generateStatCrew, index$g_generateVoluntaryConsolation as generateVoluntaryConsolation, index$g_roundRobinGroups as roundRobinGroups };
 }
 
 declare function isValidMatchUpFormat({ matchUpFormat }: {

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.1.4';
+    return '2.1.6';
 }
 
 function isFunction(obj) {
@@ -5790,6 +5790,10 @@ function getParticipantMap({ withIndividualParticipants, convertExtensions, tour
     for (const participant of tournamentRecord.participants ?? []) {
         const participantCopy = makeDeepCopy(participant, convertExtensions, internalUse);
         const { participantId, individualParticipantIds, participantType } = participantCopy;
+        if (!participantMap[participantId]) {
+            missingParticipantIds.push(participantId);
+            continue;
+        }
         Object.assign(participantMap[participantId].participant, participantCopy);
         if (individualParticipantIds) {
             const result = processIndividualParticipantIds({
@@ -10435,7 +10439,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);
@@ -12903,7 +12907,7 @@ function addDrawEntries$1(params) {
         }
         return notAdded;
     }, []);
-    if (duplicateEntries.length && suppressDuplicateEntries) {
+    if (duplicateEntries.length && !suppressDuplicateEntries) {
         return decorateResult({
             context: { eventId, drawId, duplicateEntries },
             result: { error: DUPLICATE_ENTRY },
@@ -15415,22 +15419,6 @@ function luckyLoserDrawPositionAssignment(params) {
     return luckyLoserDrawPositionAssignment$1(params);
 }
 
-function alternateDrawPositionAssignment$1({ alternateParticipantId, tournamentRecord, drawDefinition, drawPosition, structureId, }) {
-    return positionParticipantAction({
-        positionActionName: 'alternateDrawPositionAssignment',
-        participantIdAttributeName: 'alternateParticipantid',
-        participantId: alternateParticipantId,
-        tournamentRecord,
-        drawDefinition,
-        drawPosition,
-        structureId,
-    });
-}
-
-function alternateDrawPositionAssignment(params) {
-    return alternateDrawPositionAssignment$1(params);
-}
-
 function modifyMappedMatchUps({ params, modMap, structure }) {
     const { tournamentRecord, drawDefinition, event } = params;
     for (const matchUp of structure.matchUps) {
@@ -15616,6 +15604,18 @@ function qualifierDrawPositionAssignment(params) {
     return qualifierDrawPositionAssignment$1(params);
 }
 
+function alternateDrawPositionAssignment({ alternateParticipantId, tournamentRecord, drawDefinition, drawPosition, structureId, }) {
+    return positionParticipantAction({
+        positionActionName: 'alternateDrawPositionAssignment',
+        participantIdAttributeName: 'alternateParticipantid',
+        participantId: alternateParticipantId,
+        tournamentRecord,
+        drawDefinition,
+        drawPosition,
+        structureId,
+    });
+}
+
 function modifySeedAssignment({ validation = true, tournamentRecord, drawDefinition, participantId, structureId, seedValue, event, }) {
     if (!drawDefinition)
         return { error: MISSING_DRAW_DEFINITION };
@@ -40182,6 +40182,114 @@ function generateFlightProfile(params) {
     }
 }
 
+function jsonToXml({ json, tagName }) {
+    const childArrays = Object.keys(json)
+        .filter((key) => Array.isArray(json[key]))
+        .map((key) => ({ key, value: json[key].filter((v) => typeof v === 'object' && Object.keys(v).length === 1) }));
+    const childObjects = Object.keys(json)
+        .filter((key) => typeof json[key] === 'object' && !Array.isArray(json[key]))
+        .map((key) => ({ key, value: json[key] }));
+    const attributes = Object.keys(json)
+        .filter((key) => ['string', 'number'].includes(typeof json[key]))
+        .map((key) => ({ key, value: json[key] }));
+    return generateTag({ tagName, attributes, childArrays, childObjects });
+}
+function generateTag(params) {
+    const { tagName, attributes = [], childArrays = [], childObjects } = params;
+    const carriageReturn = '\r\n';
+    const arrayChild = (v) => {
+        const key = Object.keys(v)[0];
+        const value = v[key];
+        return { key, value };
+    };
+    const arrayValues = childArrays
+        ?.map(({ key, value }) => generateTag({ tagName: key, childObjects: value.map(arrayChild) }))
+        .join('\r\n');
+    const childValues = childObjects
+        ?.map(({ key, value }) => jsonToXml({ tagName: key, json: value ?? [] }))
+        .join('\r\n');
+    const attributeString = attributes?.map(({ key, value }) => `${key}="${value}"`).join(' ');
+    const attributeValue = attributeString ? ` ${attributeString}` : '';
+    if (tagName === 'childArray')
+        return childValues;
+    const objectsTag = childValues?.length ? `${carriageReturn}${childValues}${carriageReturn}` : '';
+    const arraysTag = arrayValues?.length ? `${carriageReturn}${arrayValues}${carriageReturn}` : '';
+    return `<${tagName}${attributeValue}>${objectsTag}${arraysTag}</${tagName}>`;
+}
+
+function generateStatCrew(params) {
+    const paramsCheck = checkRequiredParameters(params, [{ [TOURNAMENT_RECORD]: true }]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const { tournamentRecord } = params;
+    const { startDate, tournamentId, tournamentName } = 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 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 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 = {
+        venue: {
+            tournament: teamParticipants?.length > 2 ? 'Y' : 'N',
+            neutralgame: !homeTeam ? 'Y' : 'N',
+            tournamentname: tournamentName,
+            gameid: tournamentId,
+            officials: {},
+            rules: {},
+            homename,
+            visname,
+            homeid,
+            visid,
+            date,
+        },
+        singles_matches: singles?.map(mapMatchUp),
+        doubles_matches: doubles?.map(mapMatchUp),
+    };
+    const xml = jsonToXml({ json, tagName: 'tngame' });
+    return { xml, ...SUCCESS };
+}
+
 const ASC = 'ASC';
 const ASCENDING = 'ASC';
 const DESC = 'DESC';
@@ -40717,6 +40825,7 @@ var index$b = {
     generateLineUps: generateLineUps,
     generateQualifyingStructure: generateQualifyingStructure,
     generateSeedingScaleItems: generateSeedingScaleItems,
+    generateStatCrew: generateStatCrew,
     generateVoluntaryConsolation: generateVoluntaryConsolation,
     roundRobinGroups: roundRobinGroups
 };
@@ -42237,7 +42346,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,
@@ -42246,7 +42361,7 @@ function removeDirectedBye({ inContextDrawMatchUps, tournamentRecord, drawDefini
         structureId,
         event,
     });
-    return { ...SUCCESS };
+    return decorateResult({ result, stack });
 }
 
 function lastSetFormatIsTimed(inContextMatchUp) {
@@ -42890,24 +43005,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,
@@ -42916,22 +43034,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,
@@ -42943,8 +43063,8 @@ function removeDoubleExit(params) {
         else {
             const result = conditionallyRemoveDrawPosition({
                 ...params,
-                structure: loserStructure,
                 targetMatchUp: loserMatchUp,
+                structure: loserStructure,
                 iteration,
             });
             if (result.error)
@@ -42956,7 +43076,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,
@@ -42996,15 +43116,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,
@@ -45024,7 +45145,7 @@ function resetAdHocMatchUps(params) {
     return { ...SUCCESS };
 }
 
-function setOrderOfFinish$1({ drawDefinition, finishingOrder }) {
+function setOrderOfFinish$1({ tournamentRecord, drawDefinition, finishingOrder }) {
     if (!drawDefinition)
         return { error: MISSING_DRAW_DEFINITION };
     const stack = 'setOrderOfFinish';
@@ -45125,7 +45246,15 @@ function setOrderOfFinish$1({ drawDefinition, finishingOrder }) {
         });
         if (result.error)
             return decorateResult({ result, stack });
-        result.completedMatchUps?.forEach((matchUp) => (matchUp.orderOfFinish = valuesMap[matchUp.matchUpId]));
+        result.completedMatchUps?.forEach((matchUp) => {
+            matchUp.orderOfFinish = valuesMap[matchUp.matchUpId];
+            modifyMatchUpNotice({
+                tournamentId: tournamentRecord.tournamentId,
+                context: 'setOrderOfFinish',
+                drawDefinition,
+                matchUp,
+            });
+        });
     }
     return { ...SUCCESS };
 }