tods-competition-factory 2.0.39 → 2.0.40

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.0.39';
+    return '2.0.40';
 }
 
 function isFunction(obj) {
@@ -1256,6 +1256,9 @@ function skewedDistribution(min, max, skew, step, significantDecimals = 2) {
         num = stepRound(num, step);
     return parseFloat(num.toFixed(significantDecimals));
 }
+function fixedDecimals(value, to = 2) {
+    return parseFloat(Number(Math.round(value * 1000) / 1000).toFixed(to));
+}
 
 function unique(arr) {
     if (!Array.isArray(arr))
@@ -19702,6 +19705,153 @@ function generateAndPopulateRRplayoffStructures(params) {
     };
 }
 
+function convertRange({ value, sourceRange, targetRange }) {
+    const minSourceRange = Math.min(...sourceRange);
+    const maxSourceRange = Math.max(...sourceRange);
+    const minTargetRange = Math.min(...targetRange);
+    const maxTargetRange = Math.max(...targetRange);
+    return (((value - minSourceRange) * (maxTargetRange - minTargetRange)) / (maxSourceRange - minSourceRange) + minTargetRange);
+}
+
+const ELO = 'ELO';
+const NTRP = 'NTRP';
+const TRN = 'TRN';
+const UTR = 'UTR';
+const WTN = 'WTN';
+const ratingConstants = {
+    ELO,
+    NTRP,
+    TRN,
+    UTR,
+    WTN,
+};
+
+const ratingsParameters = {
+    [ELO]: {
+        defaultInitialization: 1500,
+        decimalsCount: 0,
+        range: [0, 3000],
+        ascending: true,
+    },
+    [NTRP]: {
+        accessors: ['ntrpRating', 'dntrpRatingHundredths'],
+        attributes: { ustaRatingType: '' },
+        accessor: 'dntrpRatingHundredths',
+        defaultInitialization: 3,
+        decimalsCount: 1,
+        ascending: true,
+        range: [1, 7],
+    },
+    [UTR]: {
+        defaultInitialization: 6,
+        accessors: ['utrRating'],
+        accessor: 'utrRating',
+        decimalsCount: 2,
+        ascending: true,
+        range: [1, 16],
+    },
+    [WTN]: {
+        attributes: { confidence: { generator: true, range: [60, 100] } },
+        accessors: ['wtnRating', 'confidence'],
+        defaultInitialization: 23,
+        accessor: 'wtnRating',
+        ascending: false,
+        decimalsCount: 2,
+        range: [40, 1],
+    },
+};
+
+function getRatingConvertedToELO({ sourceRatingType, sourceRating }) {
+    const sourceRatingRange = ratingsParameters[sourceRatingType].range;
+    const invertedScale = sourceRatingRange[0] > sourceRatingRange[1];
+    const eloRatingRange = ratingsParameters[ELO].range;
+    return convertRange({
+        value: invertedScale ? sourceRatingRange[0] - sourceRating : sourceRating,
+        sourceRange: sourceRatingRange,
+        targetRange: eloRatingRange,
+    });
+}
+function getRatingConvertedFromELO({ targetRatingType, sourceRating }) {
+    const decimalPlaces = ratingsParameters[targetRatingType].decimalsCount || 0;
+    const targetRatingRange = ratingsParameters[targetRatingType].range;
+    const invertedScale = targetRatingRange[0] > targetRatingRange[1];
+    const maxTargetRatingRange = Math.max(...targetRatingRange);
+    const eloRatingRange = ratingsParameters[ELO].range;
+    const result = convertRange({
+        targetRange: targetRatingRange,
+        sourceRange: eloRatingRange,
+        value: sourceRating,
+    });
+    const convertedRating = parseFloat(result.toFixed(decimalPlaces));
+    return invertedScale ? maxTargetRatingRange - convertedRating : convertedRating;
+}
+
+function getConvertedRating(params) {
+    const paramsCheck = checkRequiredParameters(params, [{ ratings: true, [OF_TYPE]: OBJECT }]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const matchUpType = params.matchUpType && [SINGLES, DOUBLES].includes(params.matchUpType) ? params.matchUpType : SINGLES;
+    const ratingTypes = Object.keys(ratingsParameters);
+    const targetRatingType = params.targetRatingType && ratingTypes.includes(params.targetRatingType) ? params.targetRatingType : ELO;
+    const sourceRatings = params.ratings[matchUpType]
+        ? params.ratings[matchUpType].reduce((sr, rating) => (sr.includes(rating.scaleName) ? sr : sr.concat(rating.scaleName)), [])
+        : [];
+    if (!sourceRatings)
+        return { error: NOT_FOUND };
+    const sourceRatingObject = params.ratings[matchUpType]?.find((rating) => rating.scaleName === targetRatingType) ??
+        params.ratings[matchUpType][0];
+    if (sourceRatings[0] === targetRatingType)
+        return sourceRatingObject;
+    const sourceRatingType = sourceRatingObject.scaleName;
+    const accessor = ratingsParameters[sourceRatingObject.scaleName].accessor;
+    const sourceRating = accessor ? sourceRatingObject.scaleValue[accessor] : sourceRatingObject.scaleValue;
+    const eloValue = getRatingConvertedToELO({ sourceRatingType, sourceRating });
+    const convertedRating = getRatingConvertedFromELO({
+        targetRatingType: targetRatingType,
+        sourceRating: eloValue,
+    });
+    return { convertedRating, sourceRating };
+}
+
+function calculatePressureRatings({ participantResults, sides, score }) {
+    const side1 = sides.find(({ sideNumber }) => sideNumber === 1);
+    const side2 = sides.find(({ sideNumber }) => sideNumber === 2);
+    const side1ratings = side1?.participant?.ratings;
+    const side2ratings = side2?.participant?.ratings;
+    if (side1ratings[SINGLES] && side2ratings[SINGLES]) {
+        const targetRatingType = ELO;
+        const { convertedRating: side1ConvertedRating } = getConvertedRating({ ratings: side1ratings, targetRatingType });
+        const { convertedRating: side2ConvertedRating } = getConvertedRating({ ratings: side2ratings, targetRatingType });
+        const { side1pressure, side2pressure } = getSideValues$1({ side1ConvertedRating, side2ConvertedRating, score });
+        participantResults[side1?.participantId].pressureScores.push(side1pressure);
+        participantResults[side2?.participantId].pressureScores.push(side2pressure);
+        const highRange = Math.max(...ratingsParameters[ELO].range);
+        const side1Variation = fixedDecimals((side2ConvertedRating - side1ConvertedRating) / highRange);
+        const side2Variation = fixedDecimals((side1ConvertedRating - side2ConvertedRating) / highRange);
+        participantResults[side1?.participantId].ratingVariation.push(side1Variation);
+        participantResults[side2?.participantId].ratingVariation.push(side2Variation);
+    }
+}
+function getSideValues$1({ side1ConvertedRating, side2ConvertedRating, score }) {
+    const highRating = side1ConvertedRating > side2ConvertedRating ? side1ConvertedRating : side2ConvertedRating;
+    const lowRating = side1ConvertedRating > side2ConvertedRating ? side2ConvertedRating : side1ConvertedRating;
+    const ratingsDifference = Math.abs(side1ConvertedRating - side2ConvertedRating);
+    const eloRatingRange = ratingsParameters[ELO].range;
+    const rangeMax = Math.max(...eloRatingRange);
+    const bumpBump = (rangeMax - highRating) * 0;
+    const discount = (highRating + bumpBump) / rangeMax;
+    const lowSideBump = discount * ratingsDifference;
+    const gamesWonSide1 = score?.sets?.reduce((total, set) => total + (set?.side1Score ?? 0), 0);
+    const gamesWonSide2 = score?.sets?.reduce((total, set) => total + (set.side2Score ?? 0), 0);
+    const lowSide = side1ConvertedRating > side2ConvertedRating ? 2 : 1;
+    const side1value = gamesWonSide1 * (lowRating + (lowSide === 1 ? lowSideBump : 0));
+    const side2value = gamesWonSide2 * (lowRating + (lowSide === 2 ? lowSideBump : 0));
+    const combinedValues = side1value + side2value;
+    const side1pressure = fixedDecimals(side1value / combinedValues);
+    const side2pressure = fixedDecimals(side2value / combinedValues);
+    return { side1pressure, side2pressure };
+}
+
 const FORMAT_STANDARD = 'SET3-S:6/TB7';
 const FORMAT_STANDARD_NOAD = 'SET3-S:6NOAD';
 const FORMAT_ATP_DOUBLES = 'SET3-S:6/TB7-F:TB10';
@@ -19907,114 +20057,6 @@ function calculatePercentages({ participantResults, matchUpFormat, tallyPolicy,
     });
 }
 
-function convertRange({ value, sourceRange, targetRange }) {
-    const minSourceRange = Math.min(...sourceRange);
-    const maxSourceRange = Math.max(...sourceRange);
-    const minTargetRange = Math.min(...targetRange);
-    const maxTargetRange = Math.max(...targetRange);
-    return (((value - minSourceRange) * (maxTargetRange - minTargetRange)) / (maxSourceRange - minSourceRange) + minTargetRange);
-}
-
-const ELO = 'ELO';
-const NTRP = 'NTRP';
-const TRN = 'TRN';
-const UTR = 'UTR';
-const WTN = 'WTN';
-const ratingConstants = {
-    ELO,
-    NTRP,
-    TRN,
-    UTR,
-    WTN,
-};
-
-const ratingsParameters = {
-    [ELO]: {
-        defaultInitialization: 1500,
-        decimalsCount: 0,
-        range: [0, 3000],
-        ascending: true,
-    },
-    [NTRP]: {
-        accessors: ['ntrpRating', 'dntrpRatingHundredths'],
-        attributes: { ustaRatingType: '' },
-        accessor: 'dntrpRatingHundredths',
-        defaultInitialization: 3,
-        decimalsCount: 1,
-        ascending: true,
-        range: [1, 7],
-    },
-    [UTR]: {
-        defaultInitialization: 6,
-        accessors: ['utrRating'],
-        accessor: 'utrRating',
-        decimalsCount: 2,
-        ascending: true,
-        range: [1, 16],
-    },
-    [WTN]: {
-        attributes: { confidence: { generator: true, range: [60, 100] } },
-        accessors: ['wtnRating', 'confidence'],
-        defaultInitialization: 23,
-        accessor: 'wtnRating',
-        ascending: false,
-        decimalsCount: 2,
-        range: [40, 1],
-    },
-};
-
-function getRatingConvertedToELO({ sourceRatingType, sourceRating }) {
-    const sourceRatingRange = ratingsParameters[sourceRatingType].range;
-    const invertedScale = sourceRatingRange[0] > sourceRatingRange[1];
-    const eloRatingRange = ratingsParameters[ELO].range;
-    return convertRange({
-        value: invertedScale ? sourceRatingRange[0] - sourceRating : sourceRating,
-        sourceRange: sourceRatingRange,
-        targetRange: eloRatingRange,
-    });
-}
-function getRatingConvertedFromELO({ targetRatingType, sourceRating }) {
-    const decimalPlaces = ratingsParameters[targetRatingType].decimalsCount || 0;
-    const targetRatingRange = ratingsParameters[targetRatingType].range;
-    const invertedScale = targetRatingRange[0] > targetRatingRange[1];
-    const maxTargetRatingRange = Math.max(...targetRatingRange);
-    const eloRatingRange = ratingsParameters[ELO].range;
-    const result = convertRange({
-        targetRange: targetRatingRange,
-        sourceRange: eloRatingRange,
-        value: sourceRating,
-    });
-    const convertedRating = parseFloat(result.toFixed(decimalPlaces));
-    return invertedScale ? maxTargetRatingRange - convertedRating : convertedRating;
-}
-
-function getConvertedRating(params) {
-    const paramsCheck = checkRequiredParameters(params, [{ ratings: true, [OF_TYPE]: OBJECT }]);
-    if (paramsCheck.error)
-        return paramsCheck;
-    const matchUpType = params.matchUpType && [SINGLES, DOUBLES].includes(params.matchUpType) ? params.matchUpType : SINGLES;
-    const ratingTypes = Object.keys(ratingsParameters);
-    const targetRatingType = params.targetRatingType && ratingTypes.includes(params.targetRatingType) ? params.targetRatingType : ELO;
-    const sourceRatings = params.ratings[matchUpType]
-        ? params.ratings[matchUpType].reduce((sr, rating) => (sr.includes(rating.scaleName) ? sr : sr.concat(rating.scaleName)), [])
-        : [];
-    if (!sourceRatings)
-        return { error: NOT_FOUND };
-    const sourceRatingObject = params.ratings[matchUpType]?.find((rating) => rating.scaleName === targetRatingType) ??
-        params.ratings[matchUpType][0];
-    if (sourceRatings[0] === targetRatingType)
-        return sourceRatingObject;
-    const sourceRatingType = sourceRatingObject.scaleName;
-    const accessor = ratingsParameters[sourceRatingObject.scaleName].accessor;
-    const sourceRating = accessor ? sourceRatingObject.scaleValue[accessor] : sourceRatingObject.scaleValue;
-    const eloValue = getRatingConvertedToELO({ sourceRatingType, sourceRating });
-    const convertedRating = getRatingConvertedFromELO({
-        targetRatingType: targetRatingType,
-        sourceRating: eloValue,
-    });
-    return { convertedRating, sourceRating };
-}
-
 function getParticipantResults({ participantIds, pressureRating, matchUpFormat, tallyPolicy, perPlayer, matchUps, }) {
     const participantResults = {};
     const excludeMatchUpStatuses = tallyPolicy?.excludeMatchUpStatuses || [];
@@ -20134,6 +20176,7 @@ function getParticipantResults({ participantIds, pressureRating, matchUpFormat,
                     processMatchUp({
                         matchUpFormat: tieMatchUp.matchUpFormat,
                         matchUpStatus: tieMatchUp.matchUpStatus,
+                        matchUpType: tieMatchUp.matchUpType,
                         score: tieMatchUp.score,
                         sides: tieMatchUp.sides,
                         winningParticipantId,
@@ -20156,6 +20199,7 @@ function getParticipantResults({ participantIds, pressureRating, matchUpFormat,
             else {
                 processMatchUp({
                     matchUpFormat: matchUp.matchUpFormat ?? matchUpFormat,
+                    matchUpType: matchUp.matchUpType,
                     isTieMatchUp: undefined,
                     winningParticipantId,
                     manualGamesOverride,
@@ -20269,24 +20313,11 @@ function processScore({ manualGamesOverride, participantResults, score, sides })
         }
     });
 }
-function processMatchUp({ winningParticipantId, manualGamesOverride, losingParticipantId, participantResults, pressureRating, matchUpFormat, matchUpStatus, isTieMatchUp, tallyPolicy, winningSide, score, sides, }) {
+function processMatchUp({ winningParticipantId, manualGamesOverride, losingParticipantId, participantResults, pressureRating, matchUpFormat, matchUpStatus, isTieMatchUp, matchUpType, tallyPolicy, winningSide, score, sides, }) {
     const winningSideIndex = winningSide && winningSide - 1;
     const losingSideIndex = 1 - winningSideIndex;
-    if (pressureRating) {
-        const fixed2 = (value) => parseFloat(Number(Math.round(value * 1000) / 1000).toFixed(2));
-        const gamesWonSide1 = score?.sets?.reduce((total, set) => total + (set?.side1Score ?? 0), 0);
-        const gamesWonSide2 = score?.sets?.reduce((total, set) => total + (set.side2Score ?? 0), 0);
-        const side1 = sides.find(({ sideNumber }) => sideNumber === 1);
-        const side2 = sides.find(({ sideNumber }) => sideNumber === 2);
-        const { convertedRating: side1ConvertedRating } = getConvertedRating({ ratings: side1?.participant?.ratings });
-        const { convertedRating: side2ConvertedRating } = getConvertedRating({ ratings: side2?.participant?.ratings });
-        const side1Value = gamesWonSide1 * side2ConvertedRating;
-        const side2Value = gamesWonSide2 * side1ConvertedRating;
-        participantResults[side1?.participantId].pressureScores.push(fixed2(side1Value / (side1Value + side2Value)));
-        participantResults[side2?.participantId].pressureScores.push(fixed2(side2Value / (side1Value + side2Value)));
-        const highRange = Math.max(...ratingsParameters[ELO].range);
-        participantResults[side1?.participantId].ratingVariation.push(fixed2((side1ConvertedRating - side2ConvertedRating) / highRange));
-        participantResults[side2?.participantId].ratingVariation.push(fixed2((side2ConvertedRating - side1ConvertedRating) / highRange));
+    if (pressureRating && matchUpType === SINGLES) {
+        calculatePressureRatings({ participantResults, sides, score });
     }
     if (!isTieMatchUp) {
         processOutcome$1({
@@ -26542,9 +26573,9 @@ function calculateNewRatings(params) {
     const updatedWinnerRating = invertedScale
         ? ratingRange[0] - convertedUpdatedWinnerRating
         : convertedUpdatedWinnerRating;
-    let newWinnerRating = parseFloat(parseFloat(updatedWinnerRating).toFixed(decimalPlaces));
+    let newWinnerRating = parseFloat(updatedWinnerRating.toFixed(decimalPlaces));
     const updatedLoserRating = invertedScale ? ratingRange[0] - convertedUpdatedLoserRating : convertedUpdatedLoserRating;
-    let newLoserRating = parseFloat(parseFloat(updatedLoserRating).toFixed(decimalPlaces));
+    let newLoserRating = parseFloat(updatedLoserRating.toFixed(decimalPlaces));
     const percentageDifference = Math.max(...ratingRange)
         ? Math.abs(winnerRating - loserRating) / Math.max(...ratingRange)
         : 0;