tods-competition-factory 1.7.3 → 1.7.5

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

@@ -362,7 +362,7 @@ var matchUpFormatCode = {
 };
 
 function factoryVersion() {
-    return '1.7.3';
+    return '1.7.5';
 }
 
 /******************************************************************************
@@ -5511,6 +5511,7 @@ function getMatchUpFormatAverageTimes(_a) {
     });
 }
 
+var DYNAMIC = 'DYNAMIC';
 var RANKING$1 = 'RANKING';
 var RATING$2 = 'RATING';
 var SCALE$1 = 'SCALE';
@@ -5551,7 +5552,8 @@ function getScaleValues(_a) {
                 var itemType = itemTypes_1_1.value;
                 var scaleItem = latestScaleItem(itemType);
                 if (scaleItem) {
-                    var _d = __read(scaleItem.itemType.split('.'), 4), type = _d[1], format = _d[2], scaleName = _d[3];
+                    var _d = __read(scaleItem.itemType.split('.'), 5), type = _d[1], format = _d[2], scaleName = _d[3], modifier = _d[4];
+                    var namedScale = modifier ? "".concat(scaleName, ".").concat(modifier) : scaleName;
                     var scaleType = (type === SEEDING$1 && 'seedings') ||
                         (type === RANKING$1 && 'rankings') ||
                         'ratings';
@@ -5560,7 +5562,7 @@ function getScaleValues(_a) {
                     scales[scaleType][format].push({
                         scaleValue: scaleItem.itemValue,
                         scaleDate: scaleItem.itemDate,
-                        scaleName: scaleName,
+                        scaleName: namedScale,
                     });
                 }
             }
@@ -14954,21 +14956,27 @@ var _a$g;
 var ratingsParameters = (_a$g = {},
     _a$g[ELO] = { range: [0, 3000], decimalsCount: 0, defaultInitialization: 1500 },
     _a$g[NTRP] = {
-        range: [1, 7],
-        decimalsCount: 1,
-        defaultInitialization: 3,
-        accessor: 'dntrpRatingHundredths',
         accessors: ['ntrpRating', 'dntrpRatingHundredths'],
         attributes: { ustaRatingType: '' },
+        accessor: 'dntrpRatingHundredths',
+        defaultInitialization: 3,
+        decimalsCount: 1,
+        range: [1, 7],
     },
-    _a$g[UTR] = { range: [1, 16], decimalsCount: 2, defaultInitialization: 6 },
-    _a$g[WTN] = {
-        range: [40, 1],
+    _a$g[UTR] = {
+        defaultInitialization: 6,
+        accessors: ['utrRating'],
+        accessor: 'utrRating',
         decimalsCount: 2,
+        range: [1, 16],
+    },
+    _a$g[WTN] = {
+        attributes: { confidence: { generator: true, range: [60, 100] } },
+        accessors: ['wtnRating', 'confidence'],
         defaultInitialization: 23,
         accessor: 'wtnRating',
-        accessors: ['wtnRating'],
-        attributes: { confidence: { generator: true, range: [60, 100] } },
+        decimalsCount: 2,
+        range: [40, 1],
     },
     _a$g);
 
@@ -42135,10 +42143,7 @@ function treeMatchUps(_a) {
         uuids: uuids,
     }), roundNodes = _b.roundNodes, matchUps = _b.matchUps);
     roundNumber++;
-    roundLimit =
-        roundLimit ||
-            qualifyingRoundNumber ||
-            (qualifyingPositions ? drawSize / 2 / qualifyingPositions : undefined);
+    roundLimit = roundLimit || qualifyingRoundNumber;
     while (roundNodes.length > 1) {
         if (qualifyingPositions && roundNodes.length === qualifyingPositions) {
             roundLimit = roundNumber - 1;
@@ -43025,7 +43030,7 @@ function feedInLinks(_a) {
 }
 
 function generateCurtisConsolation(params) {
-    var finishingPositionOffset = params.finishingPositionOffset, _a = params.structureName, structureName = _a === void 0 ? MAIN : _a, _b = params.stageSequence, stageSequence = _b === void 0 ? 1 : _b, staggeredEntry = params.staggeredEntry, _c = params.stage, stage = _c === void 0 ? MAIN : _c, matchUpType = params.matchUpType, structureId = params.structureId, drawSize = params.drawSize, idPrefix = params.idPrefix, isMock = params.isMock, uuids = params.uuids;
+    var finishingPositionOffset = params.finishingPositionOffset, _a = params.structureName, structureName = _a === void 0 ? MAIN : _a, _b = params.stageSequence, stageSequence = _b === void 0 ? 1 : _b, structureNameMap = params.structureNameMap, staggeredEntry = params.staggeredEntry, _c = params.stage, stage = _c === void 0 ? MAIN : _c, matchUpType = params.matchUpType, structureId = params.structureId, drawSize = params.drawSize, idPrefix = params.idPrefix, isMock = params.isMock, uuids = params.uuids;
     var mainParams = {
         finishingPositionOffset: finishingPositionOffset,
         matchUpType: matchUpType,
@@ -43052,8 +43057,9 @@ function generateCurtisConsolation(params) {
         var consolationItems = feedRoundOffsets.map(function (roundOffset, index) {
             var stageSequence = index + 1;
             var consolationStructure = consolationFeedStructure({
-                structureId: uuids === null || uuids === void 0 ? void 0 : uuids.pop(),
                 idPrefix: idPrefix && "".concat(idPrefix, "-c").concat(index),
+                structureId: uuids === null || uuids === void 0 ? void 0 : uuids.pop(),
+                structureNameMap: structureNameMap,
                 stageSequence: stageSequence,
                 roundOffset: roundOffset,
                 matchUpType: matchUpType,
@@ -43086,9 +43092,9 @@ function generateCurtisConsolation(params) {
                 isMock: isMock,
             }).matchUps;
             var playoffStructure = structureTemplate({
+                structureName: (structureNameMap === null || structureNameMap === void 0 ? void 0 : structureNameMap[PLAY_OFF]) || PLAY_OFF,
                 structureId: uuids === null || uuids === void 0 ? void 0 : uuids.pop(),
                 matchUps: playoffMatchUps,
-                structureName: PLAY_OFF,
                 stageSequence: 2,
                 stage: PLAY_OFF,
                 matchUpType: matchUpType,
@@ -43112,7 +43118,7 @@ function generateCurtisConsolation(params) {
     return __assign({ structures: structures, links: links }, SUCCESS);
 }
 function consolationFeedStructure(_a) {
-    var _b = _a.stageSequence, stageSequence = _b === void 0 ? 1 : _b, _c = _a.roundOffset, roundOffset = _c === void 0 ? 0 : _c, matchUpType = _a.matchUpType, structureId = _a.structureId, idPrefix = _a.idPrefix, drawSize = _a.drawSize, isMock = _a.isMock, index = _a.index, uuids = _a.uuids;
+    var _b = _a.stageSequence, stageSequence = _b === void 0 ? 1 : _b, structureNameMap = _a.structureNameMap, _c = _a.roundOffset, roundOffset = _c === void 0 ? 0 : _c, matchUpType = _a.matchUpType, structureId = _a.structureId, idPrefix = _a.idPrefix, drawSize = _a.drawSize, isMock = _a.isMock, index = _a.index, uuids = _a.uuids;
     var consolationDrawPositions = drawSize / (2 * Math.pow(2, roundOffset));
     var _d = feedInMatchUps({
         finishingPositionOffset: consolationDrawPositions,
@@ -43124,7 +43130,8 @@ function consolationFeedStructure(_a) {
         isMock: isMock,
         uuids: uuids,
     }), consolationMatchUps = _d.matchUps, consolationRoundsCount = _d.roundsCount;
-    var structureName = "".concat(CONSOLATION, " ").concat(index + 1);
+    var defaultName = "".concat(CONSOLATION, " ").concat(index + 1);
+    var structureName = (structureNameMap === null || structureNameMap === void 0 ? void 0 : structureNameMap[defaultName]) || defaultName;
     var consolationStructure = structureTemplate({
         matchUps: consolationMatchUps,
         stage: CONSOLATION,
@@ -43383,6 +43390,7 @@ function processPlayoffGroups(_a) {
         }
         var params = {
             structureId: (_c = playoffGroup.structureId) !== null && _c !== void 0 ? _c : uuids === null || uuids === void 0 ? void 0 : uuids.pop(),
+            structureNameMap: playoffGroup.structureNameMap,
             structureName: playoffGroup.structureName,
             idPrefix: idPrefix && "".concat(idPrefix, "-po"),
             appliedPolicies: policyDefinitions,
@@ -50536,59 +50544,96 @@ function removeDelegatedOutcome$1(_a) {
 }
 
 function generateCandidate(_a) {
-    var _b = _a.maxIterations, maxIterations = _b === void 0 ? 5000 : _b, // cap the processing intensity of the candidate generator
+    var _b = _a.maxIterations, maxIterations = _b === void 0 ? 4000 : _b, // cap the processing intensity of the candidate generator
     valueSortedPairings = _a.valueSortedPairings, // pairings sorted by value from low to high
-    pairingValues = _a.pairingValues, deltaObjects = _a.deltaObjects;
-    var rankedMatchUpValues = Object.assign.apply(Object, __spreadArray([{}], __read(valueSortedPairings.map(function (rm) {
+    pairingValues = _a.pairingValues, valueObjects = _a.valueObjects, deltaObjects = _a.deltaObjects;
+    var pairingValueMap = Object.assign.apply(Object, __spreadArray([{}], __read(valueSortedPairings.map(function (rm) {
         var _a;
         return (_a = {}, _a[rm.pairing] = rm.value, _a);
     })), false));
+    var actors = Object.keys(pairingValues);
+    var proposedCandidates = [];
     // generate an initial candidate value with no stipulated pairings
-    var candidate = roundCandidate({
-        rankedMatchUpValues: rankedMatchUpValues,
+    var initialProposal = roundCandidate({
+        actorsCount: actors.length,
         valueSortedPairings: valueSortedPairings,
+        pairingValueMap: pairingValueMap,
         deltaObjects: deltaObjects,
+        valueObjects: valueObjects,
     });
-    var deltaCandidate = candidate;
-    var actors = Object.keys(pairingValues);
+    var candidateHashes = [candidateHash(initialProposal)];
+    proposedCandidates.push(initialProposal);
+    var lowCandidateValue = initialProposal.value;
+    var deltaCandidate = initialProposal;
     // iterations is the number of loops over valueSortedPairings
     var candidatesCount = 0;
-    var iterations;
-    // calculate the number of opponents to consider for each participantId
+    var iterations = 0;
     var opponentCount = actors.length;
+    var calculatedIterations;
+    // calculate the number of opponents to consider for each participantId
     do {
         opponentCount -= 1;
-        iterations =
-            (actors.length * opponentCount * valueSortedPairings.length) / 2;
-    } while (iterations > maxIterations && opponentCount > 2);
+        calculatedIterations = actors.length * pairingValues[actors[0]].length;
+    } while (calculatedIterations > maxIterations && opponentCount > 5);
+    // keep track of proposed pairings
     var stipulatedPairs = [];
     // for each actor generate a roundCandidate using opponentCount of pairing values
     actors.forEach(function (actor) {
         var participantIdPairings = pairingValues[actor];
         // opponentCount limits the number of opponents to consider
         participantIdPairings.slice(0, opponentCount).forEach(function (pairing) {
+            iterations += 1;
             var stipulatedPair = pairingHash(actor, pairing.opponent);
             if (!stipulatedPairs.includes(stipulatedPair)) {
                 var proposed = roundCandidate({
                     // each roundCandidate starts with stipulated pairings
                     stipulated: [[actor, pairing.opponent]],
-                    rankedMatchUpValues: rankedMatchUpValues,
+                    actorsCount: actors.length,
                     valueSortedPairings: valueSortedPairings,
+                    pairingValueMap: pairingValueMap,
                     deltaObjects: deltaObjects,
+                    valueObjects: valueObjects,
                 });
-                if (proposed.maxDelta < deltaCandidate.maxDelta)
-                    deltaCandidate = proposed;
-                if (proposed.value < candidate.value)
-                    candidate = proposed;
-                stipulatedPairs.push(stipulatedPair);
-                candidatesCount += 1;
+                // ensure no duplicate candidates are considered
+                if (!candidateHashes.includes(candidateHash(proposed))) {
+                    candidateHashes.push(candidateHash(proposed));
+                    proposedCandidates.push(proposed);
+                    var maxDelta = proposed.maxDelta, value = proposed.value;
+                    if (maxDelta < deltaCandidate.maxDelta)
+                        deltaCandidate = proposed;
+                    if (value < lowCandidateValue ||
+                        (value === lowCandidateValue && Math.round(Math.random())) // randomize if equivalent values
+                    ) {
+                        lowCandidateValue = value;
+                    }
+                    stipulatedPairs.push(stipulatedPair);
+                    candidatesCount += 1;
+                }
             }
         });
+        proposedCandidates = proposedCandidates.filter(function (proposed) { return Math.abs(proposed.value - lowCandidateValue) < 5; });
     });
-    return { candidate: candidate, deltaCandidate: deltaCandidate, candidatesCount: candidatesCount, iterations: iterations };
+    proposedCandidates.sort(function (a, b) { return a.maxDiff - b.maxDiff; });
+    var candidate = randomPop(proposedCandidates);
+    return {
+        candidatesCount: candidatesCount,
+        deltaCandidate: deltaCandidate,
+        maxIterations: maxIterations,
+        iterations: iterations,
+        candidate: candidate,
+    };
+}
+function candidateHash(candidate) {
+    return candidate.participantIdPairings
+        .map(function (_a) {
+        var participantIds = _a.participantIds;
+        return participantIds.sort().join('|');
+    })
+        .sort()
+        .join('/');
 }
 function roundCandidate(_a) {
-    var rankedMatchUpValues = _a.rankedMatchUpValues, valueSortedPairings = _a.valueSortedPairings, _b = _a.stipulated, stipulated = _b === void 0 ? [] : _b, deltaObjects = _a.deltaObjects;
+    var valueSortedPairings = _a.valueSortedPairings, _b = _a.stipulated, stipulated = _b === void 0 ? [] : _b, pairingValueMap = _a.pairingValueMap, deltaObjects = _a.deltaObjects, valueObjects = _a.valueObjects, actorsCount = _a.actorsCount;
     // roundPlayers starts with the stipulated pairing
     var roundPlayers = [].concat.apply([], __spreadArray([], __read(stipulated), false));
     // aggregates the pairings generated for a roundCandidate
@@ -50600,13 +50645,19 @@ function roundCandidate(_a) {
     stipulated.filter(Boolean).forEach(function (participantIds) {
         var _a = __read(participantIds, 2), p1 = _a[0], p2 = _a[1];
         var pairing = pairingHash(p1, p2);
-        var value = rankedMatchUpValues[pairing];
+        var value = pairingValueMap[pairing];
         participantIdPairings.push({ participantIds: participantIds, value: value });
-        candidateValue += rankedMatchUpValues[pairing];
+        candidateValue += pairingValueMap[pairing];
     });
+    // valueSortedPairings is an array sorted from lowest value to highest value
+    // introduce random shuffling of chunks of valueSortedPairings
+    var consideredPairings = chunkArray(valueSortedPairings, actorsCount)
+        .map(function (pairings) {
+        return shuffleArray(pairings).map(function (pairing) { return (__assign(__assign({}, pairing), { value: pairing.value + Math.random() * Math.round(Math.random()) })); });
+    })
+        .flat();
     // go through the valueSortedPairings (of all possible unique pairings)
-    // this is an array sorted from lowest value to highest value
-    valueSortedPairings.forEach(function (rankedPairing) {
+    consideredPairings.forEach(function (rankedPairing) {
         var participantIds = rankedPairing.pairing.split('|');
         var opponentExists = participantIds.reduce(function (p, c) { return roundPlayers.includes(c) || p; }, false);
         if (!opponentExists) {
@@ -50625,21 +50676,181 @@ function roundCandidate(_a) {
         var delta = deltaObjects[hash];
         return delta > p ? delta : p;
     }, 0);
-    return { value: candidateValue, participantIdPairings: participantIdPairings, maxDelta: maxDelta };
+    // determine the greatest delta in the candidate's pairings
+    var maxDiff = participantIdPairings.reduce(function (p, c) {
+        var _a = __read(c.participantIds, 2), p1 = _a[0], p2 = _a[1];
+        var hash = pairingHash(p1, p2);
+        var diff = valueObjects[hash];
+        return diff > p ? diff : p;
+    }, 0);
+    return { value: candidateValue, participantIdPairings: participantIdPairings, maxDelta: maxDelta, maxDiff: maxDiff };
 }
 function pairingHash(id1, id2) {
     return [id1, id2].sort().join('|');
 }
 
-// this should be in policyDefinitions
-var ENCOUNTER_VALUE = 50;
-var SAME_TEAM_VALUE = 60;
+function getPairingsData(_a) {
+    var participantIds = _a.participantIds;
+    var possiblePairings = {};
+    var uniquePairings = [];
+    participantIds.forEach(function (participantId) {
+        possiblePairings[participantId] = participantIds.filter(function (id) { return id !== participantId; });
+        possiblePairings[participantId].forEach(function (id) {
+            var pairing = pairingHash(id, participantId);
+            if (!uniquePairings.includes(pairing))
+                uniquePairings.push(pairing);
+        });
+    });
+    var deltaObjects = Object.assign.apply(Object, __spreadArray([{}], __read(uniquePairings.map(function (pairing) {
+        var _a;
+        return (_a = {}, _a[pairing] = 0, _a);
+    })), false));
+    return { uniquePairings: uniquePairings, possiblePairings: possiblePairings, deltaObjects: deltaObjects };
+}
+
+function getEncounters(_a) {
+    var e_1, _b;
+    var matchUps = _a.matchUps;
+    var encounters = [];
+    try {
+        for (var matchUps_1 = __values(matchUps), matchUps_1_1 = matchUps_1.next(); !matchUps_1_1.done; matchUps_1_1 = matchUps_1.next()) {
+            var matchUp = matchUps_1_1.value;
+            var participantIds = matchUp.sides.map(extractAttributes('participantId'));
+            if (participantIds.length === 2) {
+                var _c = __read(participantIds, 2), p1 = _c[0], p2 = _c[1];
+                var pairing = pairingHash(p1, p2);
+                if (!encounters.includes(pairing))
+                    encounters.push(pairing);
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (matchUps_1_1 && !matchUps_1_1.done && (_b = matchUps_1.return)) _b.call(matchUps_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return { encounters: encounters };
+}
+
+function getParticipantPairingValues(_a) {
+    var e_1, _b;
+    var possiblePairings = _a.possiblePairings, valueObjects = _a.valueObjects;
+    var pairingValues = {};
+    var _loop_1 = function (participantId) {
+        var participantValues = possiblePairings[participantId].map(function (opponent) {
+            return pairingValue(participantId, opponent);
+        });
+        pairingValues[participantId] = participantValues.sort(function (a, b) { return a.value - b.value; });
+    };
+    try {
+        for (var _c = __values(Object.keys(possiblePairings)), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var participantId = _d.value;
+            _loop_1(participantId);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    function pairingValue(participantId, opponent) {
+        var key = pairingHash(participantId, opponent);
+        return { opponent: opponent, value: valueObjects[key] };
+    }
+    return { pairingValues: pairingValues };
+}
+
 var DEFAULT_RATING = 0;
-var MAX_ITERATIONS = 5000;
+function getSideRatings(_a) {
+    var _b, _c;
+    var tournamentParticipants = _a.tournamentParticipants, adHocRatings = _a.adHocRatings, eventType = _a.eventType, scaleName = _a.scaleName, pairing = _a.pairing;
+    var defaultRating = (_c = (_b = ratingsParameters[scaleName]) === null || _b === void 0 ? void 0 : _b.defaultInitialization) !== null && _c !== void 0 ? _c : DEFAULT_RATING;
+    return pairing.split('|').map(function (participantId) {
+        var _a;
+        if (eventType === DOUBLES) {
+            var individualParticipantIds = (_a = tournamentParticipants === null || tournamentParticipants === void 0 ? void 0 : tournamentParticipants.find(function (participant) { return participant.participantId === participantId; })) === null || _a === void 0 ? void 0 : _a.individualParticipantIds;
+            return !individualParticipantIds
+                ? defaultRating * 2
+                : individualParticipantIds === null || individualParticipantIds === void 0 ? void 0 : individualParticipantIds.map(function (participantId) { return adHocRatings[participantId] || defaultRating; });
+        }
+        else {
+            return adHocRatings[participantId] || defaultRating;
+        }
+    });
+}
+
+function getPairings(_a) {
+    var tournamentParticipants = _a.tournamentParticipants, _b = _a.adHocRatings, adHocRatings = _b === void 0 ? {} : _b, possiblePairings = _a.possiblePairings, // participant keyed; provides array of possible opponents
+    uniquePairings = _a.uniquePairings, // hashes of all possible participantId pairings
+    maxIterations = _a.maxIterations, deltaObjects = _a.deltaObjects, // difference in rating between paired participants
+    valueObjects = _a.valueObjects, // calculated value of a pairing of participants, used for sorting pairings
+    eventType = _a.eventType, scaleName = _a.scaleName, salted = _a.salted;
+    // modify valueObjects by ratings ratingsDifference squared
+    // update deltaObjects to reflect the current difference between participant's ratings
+    uniquePairings.forEach(function (pairing) {
+        var ratings = getSideRatings({
+            tournamentParticipants: tournamentParticipants,
+            adHocRatings: adHocRatings,
+            scaleName: scaleName,
+            eventType: eventType,
+            pairing: pairing,
+        });
+        var salting = (typeof salted === 'number' && salted) || 0.5;
+        var salt = (salted && (Math.round(Math.random()) ? salting : salting * -1)) || 0;
+        var ratingsDifference = Math.abs(ratings[0] - ratings[1]) + salt;
+        var pairingDelta = Math.abs(ratings[0] - ratings[1]);
+        deltaObjects[pairing] = pairingDelta;
+        if (!valueObjects[pairing])
+            valueObjects[pairing] = 0;
+        valueObjects[pairing] += ratingsDifference
+            ? Math.pow(ratingsDifference, 2)
+            : 0;
+    });
+    /**
+     * valueSortedPairings are uniquePairings sorted by the ratings difference of the pairings, lowest to highest
+     */
+    var valueSortedPairings = uniquePairings
+        .map(function (pairing) { return ({ pairing: pairing, value: valueObjects[pairing] }); })
+        .sort(function (a, b) { return a.value - b.value; });
+    /**
+     * pairingValues is keyed by participantId and provides a value-sorted array of pairings for each participantId
+     * 'actorId': [
+          { opponent: 'potentialId1', value: 1 },
+          { opponent: 'potentialId2', value: 1 },
+     */
+    var pairingValues = getParticipantPairingValues({
+        possiblePairings: possiblePairings,
+        valueObjects: valueObjects,
+    }).pairingValues;
+    var _c = generateCandidate({
+        valueSortedPairings: valueSortedPairings,
+        maxIterations: maxIterations,
+        pairingValues: pairingValues,
+        deltaObjects: deltaObjects,
+        valueObjects: valueObjects,
+    }), candidate = _c.candidate, candidatesCount = _c.candidatesCount, deltaCandidate = _c.deltaCandidate, iterations = _c.iterations;
+    var participantIdPairings = candidate.participantIdPairings;
+    return {
+        participantIdPairings: participantIdPairings,
+        candidatesCount: candidatesCount,
+        deltaCandidate: deltaCandidate,
+        iterations: iterations,
+        candidate: candidate,
+    };
+}
+
+// this should be in policyDefinitions
+var ENCOUNTER_VALUE = 100;
+var SAME_TEAM_VALUE = 100;
+var MAX_ITERATIONS = 4000;
 function generateDrawMaticRound(_a) {
     var e_1, _b, e_2, _c, e_3, _d;
     var _e, _f;
-    var _g = _a.maxIterations, maxIterations = _g === void 0 ? MAX_ITERATIONS : _g, _h = _a.generateMatchUps, generateMatchUps = _h === void 0 ? true : _h, tournamentParticipants = _a.tournamentParticipants, tournamentRecord = _a.tournamentRecord, participantIds = _a.participantIds, addToStructure = _a.addToStructure, drawDefinition = _a.drawDefinition, adHocRatings = _a.adHocRatings, structureId = _a.structureId, matchUpIds = _a.matchUpIds, eventType = _a.eventType, structure = _a.structure;
+    var _g = _a.encounterValue, encounterValue = _g === void 0 ? ENCOUNTER_VALUE : _g, _h = _a.sameTeamValue, sameTeamValue = _h === void 0 ? SAME_TEAM_VALUE : _h, _j = _a.maxIterations, maxIterations = _j === void 0 ? MAX_ITERATIONS : _j, _k = _a.generateMatchUps, generateMatchUps = _k === void 0 ? true : _k, tournamentParticipants = _a.tournamentParticipants, tournamentRecord = _a.tournamentRecord, participantIds = _a.participantIds, addToStructure = _a.addToStructure, drawDefinition = _a.drawDefinition, adHocRatings = _a.adHocRatings, structureId = _a.structureId, _l = _a.salted, salted = _l === void 0 ? 0.5 : _l, matchUpIds = _a.matchUpIds, eventType = _a.eventType, structure = _a.structure, scaleName = _a.scaleName;
     if (!drawDefinition)
         return { error: MISSING_DRAW_DEFINITION };
     if (!structure && !structureId)
@@ -50666,7 +50877,7 @@ function generateDrawMaticRound(_a) {
             var pairing = encounters_1_1.value;
             if (!valueObjects[pairing])
                 valueObjects[pairing] = 0;
-            valueObjects[pairing] += ENCOUNTER_VALUE;
+            valueObjects[pairing] += encounterValue;
         }
     }
     catch (e_1_1) { e_1 = { error: e_1_1 }; }
@@ -50692,7 +50903,7 @@ function generateDrawMaticRound(_a) {
                         var pairing = uniquePairings_1_1.value;
                         if (!valueObjects[pairing])
                             valueObjects[pairing] = 0;
-                        valueObjects[pairing] += SAME_TEAM_VALUE;
+                        valueObjects[pairing] += sameTeamValue;
                     }
                 }
                 catch (e_3_1) { e_3 = { error: e_3_1 }; }
@@ -50718,9 +50929,9 @@ function generateDrawMaticRound(_a) {
     //  'P-I-0|P-I-2': 0,
     //  'P-I-0|P-I-3': 0
     // }
-    var _j = getPairingsData({
+    var _m = getPairingsData({
         participantIds: participantIds,
-    }), uniquePairings = _j.uniquePairings, possiblePairings = _j.possiblePairings, deltaObjects = _j.deltaObjects;
+    }), uniquePairings = _m.uniquePairings, possiblePairings = _m.possiblePairings, deltaObjects = _m.deltaObjects;
     var params = {
         tournamentParticipants: tournamentParticipants,
         possiblePairings: possiblePairings,
@@ -50732,9 +50943,11 @@ function generateDrawMaticRound(_a) {
         deltaObjects: deltaObjects,
         valueObjects: valueObjects,
         eventType: eventType,
+        scaleName: scaleName,
         structure: structure,
+        salted: salted,
     };
-    var _k = getPairings(params), candidatesCount = _k.candidatesCount, participantIdPairings = _k.participantIdPairings, iterations = _k.iterations;
+    var _o = getPairings(params), candidatesCount = _o.candidatesCount, participantIdPairings = _o.participantIdPairings, iterations = _o.iterations, candidate = _o.candidate;
     if (!candidatesCount)
         return { error: NO_CANDIDATES };
     var matchUps;
@@ -50752,147 +50965,15 @@ function generateDrawMaticRound(_a) {
             return result;
         matchUps = result.matchUps;
     }
-    return __assign(__assign({}, SUCCESS), { participantIdPairings: participantIdPairings, candidatesCount: candidatesCount, iterations: iterations, matchUps: matchUps });
-}
-function getSideRatings(_a) {
-    var tournamentParticipants = _a.tournamentParticipants, adHocRatings = _a.adHocRatings, eventType = _a.eventType, pairing = _a.pairing;
-    return pairing.split('|').map(function (participantId) {
-        var _a;
-        if (eventType === DOUBLES) {
-            var individualParticipantIds = (_a = tournamentParticipants === null || tournamentParticipants === void 0 ? void 0 : tournamentParticipants.find(function (participant) { return participant.participantId === participantId; })) === null || _a === void 0 ? void 0 : _a.individualParticipantIds;
-            return !individualParticipantIds
-                ? DEFAULT_RATING * 2
-                : individualParticipantIds === null || individualParticipantIds === void 0 ? void 0 : individualParticipantIds.map(function (participantId) { return adHocRatings[participantId || DEFAULT_RATING]; });
-        }
-        else {
-            return adHocRatings[participantId] || DEFAULT_RATING;
-        }
-    });
-}
-function getPairings(_a) {
-    var tournamentParticipants = _a.tournamentParticipants, _b = _a.adHocRatings, adHocRatings = _b === void 0 ? {} : _b, possiblePairings = _a.possiblePairings, // participant keyed; provides array of possible opponents
-    uniquePairings = _a.uniquePairings, // hashes of all possible participantId pairings
-    maxIterations = _a.maxIterations, deltaObjects = _a.deltaObjects, // difference in rating between paired participants
-    valueObjects = _a.valueObjects, // calculated value of a pairing of participants, used for sorting pairings
-    eventType = _a.eventType;
-    // modify valueObjects by ratings ratingsDifference squared
-    // update deltaObjects to reflect the current difference between participant's ratings
-    uniquePairings.forEach(function (pairing) {
-        var ratings = getSideRatings({
-            tournamentParticipants: tournamentParticipants,
-            adHocRatings: adHocRatings,
-            eventType: eventType,
-            pairing: pairing,
-        });
-        var ratingsDifference = Math.abs(ratings[0] - ratings[1]) + 1;
-        deltaObjects[pairing] = Math.abs(ratings[0] - ratings[1]);
-        if (!valueObjects[pairing])
-            valueObjects[pairing] = 0;
-        valueObjects[pairing] += Math.pow(ratingsDifference, 2);
-    });
-    /**
-     * valueSortedPairings are uniquePairings sorted by the value of the pairings, lowest to highest
-     */
-    var valueSortedPairings = uniquePairings
-        .map(function (pairing) { return ({ pairing: pairing, value: valueObjects[pairing] }); })
-        .sort(function (a, b) { return a.value - b.value; });
-    /**
-     * pairingValues is keyed by participantId and provides a value-sorted array of pairings for each participantId
-     * 'actorId': [
-          { opponent: 'potentialId1', value: 1 },
-          { opponent: 'potentialId2', value: 1 },
-     */
-    var pairingValues = getParticipantPairingValues({
-        possiblePairings: possiblePairings,
-        valueObjects: valueObjects,
-    }).pairingValues;
-    var _c = generateCandidate({
-        valueSortedPairings: valueSortedPairings,
-        maxIterations: maxIterations,
-        pairingValues: pairingValues,
-        deltaObjects: deltaObjects,
-    }), candidate = _c.candidate, candidatesCount = _c.candidatesCount, iterations = _c.iterations;
-    var participantIdPairings = candidate.participantIdPairings;
-    return { candidatesCount: candidatesCount, participantIdPairings: participantIdPairings, iterations: iterations };
-}
-function getPairingsData(_a) {
-    var participantIds = _a.participantIds;
-    var possiblePairings = {};
-    var uniquePairings = [];
-    participantIds.forEach(function (participantId) {
-        possiblePairings[participantId] = participantIds.filter(function (id) { return id !== participantId; });
-        possiblePairings[participantId].forEach(function (id) {
-            var pairing = pairingHash(id, participantId);
-            if (!uniquePairings.includes(pairing))
-                uniquePairings.push(pairing);
-        });
-    });
-    var deltaObjects = Object.assign.apply(Object, __spreadArray([{}], __read(uniquePairings.map(function (pairing) {
-        var _a;
-        return (_a = {}, _a[pairing] = 0, _a);
-    })), false));
-    return { uniquePairings: uniquePairings, possiblePairings: possiblePairings, deltaObjects: deltaObjects };
-}
-function getEncounters(_a) {
-    var e_4, _b;
-    var matchUps = _a.matchUps;
-    var encounters = [];
-    try {
-        for (var matchUps_1 = __values(matchUps), matchUps_1_1 = matchUps_1.next(); !matchUps_1_1.done; matchUps_1_1 = matchUps_1.next()) {
-            var matchUp = matchUps_1_1.value;
-            var participantIds = matchUp.sides.map(getParticipantId);
-            if (participantIds.length === 2) {
-                var _c = __read(participantIds, 2), p1 = _c[0], p2 = _c[1];
-                var pairing = pairingHash(p1, p2);
-                if (!encounters.includes(pairing))
-                    encounters.push(pairing);
-            }
-        }
-    }
-    catch (e_4_1) { e_4 = { error: e_4_1 }; }
-    finally {
-        try {
-            if (matchUps_1_1 && !matchUps_1_1.done && (_b = matchUps_1.return)) _b.call(matchUps_1);
-        }
-        finally { if (e_4) throw e_4.error; }
-    }
-    return { encounters: encounters };
-}
-function getParticipantPairingValues(_a) {
-    var e_5, _b;
-    var possiblePairings = _a.possiblePairings, valueObjects = _a.valueObjects;
-    var pairingValues = {};
-    var _loop_1 = function (participantId) {
-        var participantValues = possiblePairings[participantId].map(function (opponent) {
-            return pairingValue(participantId, opponent);
-        });
-        pairingValues[participantId] = participantValues.sort(function (a, b) { return a.value - b.value; });
-    };
-    try {
-        for (var _c = __values(Object.keys(possiblePairings)), _d = _c.next(); !_d.done; _d = _c.next()) {
-            var participantId = _d.value;
-            _loop_1(participantId);
-        }
-    }
-    catch (e_5_1) { e_5 = { error: e_5_1 }; }
-    finally {
-        try {
-            if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
-        }
-        finally { if (e_5) throw e_5.error; }
-    }
-    function pairingValue(participantId, opponent) {
-        var key = pairingHash(participantId, opponent);
-        return { opponent: opponent, value: valueObjects[key] };
-    }
-    return { pairingValues: pairingValues };
+    var maxDelta = candidate.maxDelta, maxDiff = candidate.maxDiff;
+    return __assign(__assign({}, SUCCESS), { participantIdPairings: participantIdPairings, candidatesCount: candidatesCount, iterations: iterations, matchUps: matchUps, maxDelta: maxDelta, maxDiff: maxDiff });
 }
 
 function drawMatic$1(_a) {
     var e_1, _b;
     var _c, _d, _e, _f, _g;
-    var tournamentParticipants = _a.tournamentParticipants, restrictEntryStatus = _a.restrictEntryStatus, tournamentRecord = _a.tournamentRecord, generateMatchUps = _a.generateMatchUps, addToStructure = _a.addToStructure, participantIds = _a.participantIds, drawDefinition = _a.drawDefinition, scaleAccessor = _a.scaleAccessor, maxIterations = _a.maxIterations, structureId = _a.structureId, matchUpIds = _a.matchUpIds, scaleName = _a.scaleName, // custom rating name to seed dynamic ratings
-    eventType = _a.eventType, event = _a.event;
+    var tournamentParticipants = _a.tournamentParticipants, restrictEntryStatus = _a.restrictEntryStatus, _h = _a.adHocRatings, adHocRatings = _h === void 0 ? {} : _h, generateMatchUps = _a.generateMatchUps, tournamentRecord = _a.tournamentRecord, addToStructure = _a.addToStructure, participantIds = _a.participantIds, encounterValue = _a.encounterValue, sameTeamValue = _a.sameTeamValue, drawDefinition = _a.drawDefinition, scaleAccessor = _a.scaleAccessor, maxIterations = _a.maxIterations, structureId = _a.structureId, matchUpIds = _a.matchUpIds, scaleName = _a.scaleName, // custom rating name to seed dynamic ratings
+    eventType = _a.eventType, salted = _a.salted, event = _a.event;
     if (typeof drawDefinition !== 'object' ||
         (drawDefinition.drawType && drawDefinition.drawType !== AD_HOC)) {
         return { error: INVALID_DRAW_DEFINITION };
@@ -50941,11 +51022,15 @@ function drawMatic$1(_a) {
         return { error: INVALID_DRAW_DEFINITION };
     tournamentParticipants =
         (_g = tournamentParticipants !== null && tournamentParticipants !== void 0 ? tournamentParticipants : tournamentRecord.participants) !== null && _g !== void 0 ? _g : [];
-    var adHocRatings = {};
     var _loop_1 = function (participantId) {
         var participant = tournamentParticipants === null || tournamentParticipants === void 0 ? void 0 : tournamentParticipants.find(function (participant) { return participant.participantId === participantId; });
         // first see if there is already a dynamic value
-        var scaleValue = getScaleValue({ eventType: eventType, participant: participant });
+        var scaleValue = getScaleValue({
+            scaleName: "".concat(scaleName, ".").concat(DYNAMIC),
+            scaleAccessor: scaleAccessor,
+            participant: participant,
+            eventType: eventType,
+        });
         // if no dynamic value found and a seeding scaleValue is provided...
         if (!scaleValue && scaleName) {
             scaleValue = getScaleValue({
@@ -50955,44 +51040,47 @@ function drawMatic$1(_a) {
                 eventType: eventType,
             });
         }
-        if (scaleValue)
+        if (scaleValue && !adHocRatings[participantId])
             adHocRatings[participantId] = scaleValue;
     };
     try {
-        for (var _h = __values(participantIds !== null && participantIds !== void 0 ? participantIds : []), _j = _h.next(); !_j.done; _j = _h.next()) {
-            var participantId = _j.value;
+        for (var _j = __values(participantIds !== null && participantIds !== void 0 ? participantIds : []), _k = _j.next(); !_k.done; _k = _j.next()) {
+            var participantId = _k.value;
             _loop_1(participantId);
         }
     }
     catch (e_1_1) { e_1 = { error: e_1_1 }; }
     finally {
         try {
-            if (_j && !_j.done && (_b = _h.return)) _b.call(_h);
+            if (_k && !_k.done && (_b = _j.return)) _b.call(_j);
         }
         finally { if (e_1) throw e_1.error; }
     }
     // TODO: update dynamic ratings based on matchUps present from last played round
-    // use scaleEngine.processMatchUps(); see dynamicCalculations.test.ts
+    // use scaleEngine.generateDynamicRatings(); see dynamicCalculations.test.ts
     return generateDrawMaticRound({
         tournamentParticipants: tournamentParticipants,
-        tournamentRecord: tournamentRecord,
         generateMatchUps: generateMatchUps,
-        participantIds: participantIds,
+        tournamentRecord: tournamentRecord,
         addToStructure: addToStructure,
+        participantIds: participantIds,
+        encounterValue: encounterValue,
+        sameTeamValue: sameTeamValue,
         drawDefinition: drawDefinition,
         maxIterations: maxIterations,
         adHocRatings: adHocRatings,
         matchUpIds: matchUpIds,
         structure: structure,
         eventType: eventType,
+        salted: salted,
     });
 }
 function getScaleValue(_a) {
     var _b;
-    var _c = _a.eventType, eventType = _c === void 0 ? TypeEnum.Singles : _c, _d = _a.scaleName, scaleName = _d === void 0 ? 'dynamic' : _d, scaleAccessor = _a.scaleAccessor, participant = _a.participant;
+    var _c = _a.scaleType, scaleType = _c === void 0 ? RATING$2 : _c, scaleAccessor = _a.scaleAccessor, participant = _a.participant, scaleName = _a.scaleName, eventType = _a.eventType;
     var scaleAttributes = {
         eventType: eventType || TypeEnum.Singles,
-        scaleType: RATING$2,
+        scaleType: scaleType,
         scaleName: scaleName,
     };
     var result = participant &&
@@ -64649,18 +64737,18 @@ function calculateNewRatings(params) {
     var updatedWinnerRating = invertedScale
         ? ratingRange[0] - convertedUpdatedWinnerRating
         : convertedUpdatedWinnerRating;
-    var newWinnerRating = parseFloat(updatedWinnerRating).toFixed(decimalPlaces);
+    var newWinnerRating = parseFloat(parseFloat(updatedWinnerRating).toFixed(decimalPlaces));
     var updatedLoserRating = invertedScale
         ? ratingRange[0] - convertedUpdatedLoserRating
         : convertedUpdatedLoserRating;
-    var newLoserRating = parseFloat(updatedLoserRating).toFixed(decimalPlaces);
+    var newLoserRating = parseFloat(parseFloat(updatedLoserRating).toFixed(decimalPlaces));
     //  if expected winner && percentageDifference > threshold don't change ratings
     var percentageDifference = Math.max.apply(Math, __spreadArray([], __read(ratingRange), false)) ? Math.abs(winnerRating - loserRating) / Math.max.apply(Math, __spreadArray([], __read(ratingRange), false))
         : 0;
     if ((convertedUpdatedWinnerRating > convertedUpdatedLoserRating &&
         percentageDifference > eloConfig.diffThreshold) ||
-        parseFloat(newWinnerRating) < 0 ||
-        parseFloat(newLoserRating) < 0) {
+        newWinnerRating < 0 ||
+        newLoserRating < 0) {
         newWinnerRating = winnerRating;
         newLoserRating = loserRating;
     }
@@ -64675,10 +64763,10 @@ var aggregateSets = function (sets) {
     }, [0, 0])) || [0, 0]);
 };
 
-function processMatchUps(_a) {
+function generateDynamicRatings(_a) {
     var e_1, _b;
     var _c, _d;
-    var tournamentRecord = _a.tournamentRecord, _e = _a.ratingType, ratingType = _e === void 0 ? ELO : _e, considerGames = _a.considerGames, matchUpIds = _a.matchUpIds, asDynamic = _a.asDynamic;
+    var _e = _a.removePriorValues, removePriorValues = _e === void 0 ? true : _e, tournamentRecord = _a.tournamentRecord, _f = _a.ratingType, ratingType = _f === void 0 ? ELO : _f, considerGames = _a.considerGames, matchUpIds = _a.matchUpIds, asDynamic = _a.asDynamic;
     if (!tournamentRecord)
         return { error: MISSING_TOURNAMENT_RECORD };
     if (!Array.isArray(matchUpIds))
@@ -64696,7 +64784,7 @@ function processMatchUps(_a) {
         inContext: true,
     }).matchUps || [];
     var _loop_1 = function (matchUp) {
-        var e_2, _h, e_3, _j, _k, _l;
+        var e_2, _j, e_3, _k, _l, _m;
         var endDate = matchUp.endDate, matchUpFormat = matchUp.matchUpFormat, score = matchUp.score, sides = matchUp.sides, winningSide = matchUp.winningSide;
         var matchUpType = matchUp.matchUpType;
         var scaleAttributes = {
@@ -64704,7 +64792,7 @@ function processMatchUps(_a) {
             scaleName: ratingType,
             scaleType: RATING$2,
         };
-        var dynamicScaleName = "".concat(ratingType, ".DYNAMIC");
+        var dynamicScaleName = "".concat(ratingType, ".").concat(DYNAMIC);
         var dynamicScaleAttributes = {
             scaleName: dynamicScaleName,
             eventType: matchUpType,
@@ -64740,9 +64828,9 @@ function processMatchUps(_a) {
             return (participantId && (_b = {},
                 _b[participantId] = (_c = dynamicScaleItem !== null && dynamicScaleItem !== void 0 ? dynamicScaleItem : scaleItem) !== null && _c !== void 0 ? _c : {
                     scaleName: outputScaleName,
-                    scaleType: RATING$2,
                     eventType: matchUpType,
                     scaleDate: endDate,
+                    scaleType: RATING$2,
                     scaleValue: scaleValue,
                 },
                 _b));
@@ -64777,31 +64865,33 @@ function processMatchUps(_a) {
                         var loserCountables = winningSide
                             ? countables[3 - winningSide]
                             : [0, 0];
-                        var _m = calculateNewRatings({
+                        var _o = calculateNewRatings({
                             winnerCountables: winnerCountables,
                             loserCountables: loserCountables,
                             maxCountables: maxCountables,
                             winnerRating: winnerRating,
                             loserRating: loserRating,
                             ratingType: ratingType,
-                        }), newWinnerRating = _m.newWinnerRating, newLoserRating = _m.newLoserRating;
+                        }), newWinnerRating = _o.newWinnerRating, newLoserRating = _o.newLoserRating;
                         var newWinnerScaleValue = accessor
-                            ? __assign(__assign({}, winnerScaleValue), (_k = {}, _k[accessor] = newWinnerRating, _k)) : newWinnerRating;
+                            ? __assign(__assign({}, winnerScaleValue), (_l = {}, _l[accessor] = newWinnerRating, _l)) : newWinnerRating;
                         var newLoserScaleValue = accessor
-                            ? __assign(__assign({}, loserScaleValue), (_l = {}, _l[accessor] = newLoserRating, _l)) : newLoserRating;
+                            ? __assign(__assign({}, loserScaleValue), (_m = {}, _m[accessor] = newLoserRating, _m)) : newLoserRating;
                         scaleItemMap[winnerParticipantId].scaleValue = newWinnerScaleValue;
                         scaleItemMap[loserParticipantId].scaleValue = newLoserScaleValue;
                         var result = setParticipantScaleItem({
-                            scaleItem: __assign(__assign({}, scaleItemMap[winnerParticipantId]), { scaleName: outputScaleName }),
                             participantId: winnerParticipantId,
+                            removePriorValues: removePriorValues,
                             tournamentRecord: tournamentRecord,
+                            scaleItem: __assign(__assign({}, scaleItemMap[winnerParticipantId]), { scaleName: outputScaleName }),
                         });
                         if (result.error)
                             return { value: result };
                         result = setParticipantScaleItem({
-                            scaleItem: __assign(__assign({}, scaleItemMap[loserParticipantId]), { scaleName: outputScaleName }),
                             participantId: loserParticipantId,
+                            removePriorValues: removePriorValues,
                             tournamentRecord: tournamentRecord,
+                            scaleItem: __assign(__assign({}, scaleItemMap[loserParticipantId]), { scaleName: outputScaleName }),
                         });
                         if (result.error)
                             return { value: result };
@@ -64810,7 +64900,7 @@ function processMatchUps(_a) {
                 catch (e_3_1) { e_3 = { error: e_3_1 }; }
                 finally {
                     try {
-                        if (losingSideParticipantIds_1_1 && !losingSideParticipantIds_1_1.done && (_j = losingSideParticipantIds_1.return)) _j.call(losingSideParticipantIds_1);
+                        if (losingSideParticipantIds_1_1 && !losingSideParticipantIds_1_1.done && (_k = losingSideParticipantIds_1.return)) _k.call(losingSideParticipantIds_1);
                     }
                     finally { if (e_3) throw e_3.error; }
                 }
@@ -64819,15 +64909,15 @@ function processMatchUps(_a) {
         catch (e_2_1) { e_2 = { error: e_2_1 }; }
         finally {
             try {
-                if (winningSideParticipantIds_1_1 && !winningSideParticipantIds_1_1.done && (_h = winningSideParticipantIds_1.return)) _h.call(winningSideParticipantIds_1);
+                if (winningSideParticipantIds_1_1 && !winningSideParticipantIds_1_1.done && (_j = winningSideParticipantIds_1.return)) _j.call(winningSideParticipantIds_1);
             }
             finally { if (e_2) throw e_2.error; }
         }
         Object.assign(modifiedScaleValues, scaleItemMap);
     };
     try {
-        for (var _f = __values(matchUps.sort(matchUpSort)), _g = _f.next(); !_g.done; _g = _f.next()) {
-            var matchUp = _g.value;
+        for (var _g = __values(matchUps.sort(matchUpSort)), _h = _g.next(); !_h.done; _h = _g.next()) {
+            var matchUp = _h.value;
             var state_1 = _loop_1(matchUp);
             if (typeof state_1 === "object")
                 return state_1.value;
@@ -64836,7 +64926,7 @@ function processMatchUps(_a) {
     catch (e_1_1) { e_1 = { error: e_1_1 }; }
     finally {
         try {
-            if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+            if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
         }
         finally { if (e_1) throw e_1.error; }
     }
@@ -64849,7 +64939,7 @@ function processMatchUps(_a) {
 
 var governor = {
     calculateNewRatings: calculateNewRatings,
-    processMatchUps: processMatchUps,
+    generateDynamicRatings: generateDynamicRatings,
 };
 
 var scaleEngine = (function () {