tods-competition-factory 1.7.4 → 1.7.6

package/dist/index.mjs

@@ -333,7 +333,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.7.4";
+  return "1.7.6";
 }
 
 function getObjectTieFormat(obj) {
@@ -4163,7 +4163,7 @@ const WIN_RATIO$1 = "winRatio";
 const POLICY_COMPETITIVE_BANDS_DEFAULT = {
   [POLICY_TYPE_COMPETITIVE_BANDS]: {
     policyName: "Competitive Bands Default",
-    competitiveProfile: {
+    profileBands: {
       [DECISIVE]: 20,
       [ROUTINE]: 50
     }
@@ -4248,7 +4248,7 @@ function gamesPercent(scoreComponents) {
   return Math.round(minGames / maxGames * 100);
 }
 function pctSpread(pcts) {
-  return pcts.map(gamesPercent).sort().map((p) => p.toFixed(2));
+  return pcts.map(gamesPercent).sort().map((p) => parseFloat(p.toFixed(2)));
 }
 
 function findPolicy({
@@ -4269,8 +4269,8 @@ function findPolicy({
   return appliedPolicies?.[policyType] ? { policy: appliedPolicies[policyType] } : { error: POLICY_NOT_FOUND };
 }
 
-function getMatchUpCompetitiveness({
-  competitiveProfile,
+function getMatchUpCompetitiveProfile({
+  profileBands,
   tournamentRecord,
   matchUp
 }) {
@@ -4279,15 +4279,15 @@ function getMatchUpCompetitiveness({
   const { score, winningSide } = matchUp;
   if (!winningSide)
     return { error: INVALID_VALUES };
-  const policy = !competitiveProfile && tournamentRecord && findPolicy({
+  const policy = !profileBands && tournamentRecord && findPolicy({
     policyType: POLICY_TYPE_COMPETITIVE_BANDS,
     tournamentRecord
   }).policy;
-  const bandProfiles = competitiveProfile || policy?.competitiveProfile || POLICY_COMPETITIVE_BANDS_DEFAULT[POLICY_TYPE_COMPETITIVE_BANDS].competitiveProfile;
+  const bandProfiles = profileBands || policy?.profileBands || POLICY_COMPETITIVE_BANDS_DEFAULT[POLICY_TYPE_COMPETITIVE_BANDS].profileBands;
   const scoreComponents = getScoreComponents({ score });
   const spread = pctSpread([scoreComponents]);
   const competitiveness = getBand(spread, bandProfiles);
-  return { ...SUCCESS, competitiveness };
+  return { ...SUCCESS, competitiveness, pctSpread: spread };
 }
 
 function findMatchupFormatAverageTimes(params) {
@@ -4429,14 +4429,15 @@ function getScaleValues({ participant }) {
     for (const itemType of itemTypes) {
       const scaleItem = latestScaleItem(itemType);
       if (scaleItem) {
-        const [, type, format, scaleName] = scaleItem.itemType.split(".");
+        const [, type, format, scaleName, modifier] = scaleItem.itemType.split(".");
+        const namedScale = modifier ? `${scaleName}.${modifier}` : scaleName;
         const scaleType = type === SEEDING$1 && "seedings" || type === RANKING$1 && "rankings" || "ratings";
         if (!scales[scaleType][format])
           scales[scaleType][format] = [];
         scales[scaleType][format].push({
           scaleValue: scaleItem.itemValue,
           scaleDate: scaleItem.itemDate,
-          scaleName
+          scaleName: namedScale
         });
       }
     }
@@ -8011,7 +8012,7 @@ function getAllStructureMatchUps({
       ...collectionDefinition.category
     } : context?.category;
     const processCodes = matchUp.processCodes?.length && matchUp.processCodes || collectionDefinition?.processCodes?.length && collectionDefinition?.processCodes || structure?.processCodes?.length && structure?.processCodes || drawDefinition?.processCodes?.length && drawDefinition?.processCodes || event2?.processCodes?.length && event2?.processCodes || tournamentRecord?.processCodes;
-    const competitiveness = contextProfile?.withCompetitiveness && getMatchUpCompetitiveness({ ...contextContent, matchUp }).competitiveness;
+    const competitiveProfile = contextProfile?.withCompetitiveness && getMatchUpCompetitiveProfile({ ...contextContent, matchUp });
     const finishingPositionRange = matchUp.finishingPositionRange || additionalContext.finishingPositionRange;
     const onlyDefined = (obj) => definedAttributes(obj, void 0, true);
     const matchUpWithContext = {
@@ -8027,7 +8028,7 @@ function getAllStructureMatchUps({
         finishingPositionRange,
         abbreviatedRoundName,
         drawPositionsRange,
-        competitiveness,
+        competitiveProfile,
         structureName,
         stageSequence,
         drawPositions,
@@ -13380,13 +13381,19 @@ const ratingConstants = {
 };
 
 const ratingsParameters = {
-  [ELO]: { range: [0, 3e3], decimalsCount: 0, defaultInitialization: 1500 },
+  [ELO]: {
+    defaultInitialization: 1500,
+    decimalsCount: 0,
+    range: [0, 3e3],
+    ascending: true
+  },
   [NTRP]: {
     accessors: ["ntrpRating", "dntrpRatingHundredths"],
     attributes: { ustaRatingType: "" },
     accessor: "dntrpRatingHundredths",
     defaultInitialization: 3,
     decimalsCount: 1,
+    ascending: true,
     range: [1, 7]
   },
   [UTR]: {
@@ -13394,6 +13401,7 @@ const ratingsParameters = {
     accessors: ["utrRating"],
     accessor: "utrRating",
     decimalsCount: 2,
+    ascending: true,
     range: [1, 16]
   },
   [WTN]: {
@@ -13401,6 +13409,7 @@ const ratingsParameters = {
     accessors: ["wtnRating", "confidence"],
     defaultInitialization: 23,
     accessor: "wtnRating",
+    ascending: false,
     decimalsCount: 2,
     range: [40, 1]
   }
@@ -32228,8 +32237,8 @@ function checkSchedulingProfile$1({ tournamentRecords }) {
 }
 
 function scheduledSortedMatchUps({
-  matchUps = [],
-  schedulingProfile
+  schedulingProfile,
+  matchUps = []
 }) {
   const profileHash = {};
   const getHash = ({ eventId, drawId, structureId, roundNumber }) => {
@@ -38822,7 +38831,7 @@ function treeMatchUps({
     uuids
   }));
   roundNumber++;
-  roundLimit = roundLimit || qualifyingRoundNumber || (qualifyingPositions ? drawSize / 2 / qualifyingPositions : void 0);
+  roundLimit = roundLimit || qualifyingRoundNumber;
   while (roundNodes.length > 1) {
     if (qualifyingPositions && roundNodes.length === qualifyingPositions) {
       roundLimit = roundNumber - 1;
@@ -46723,6 +46732,10 @@ function removeDelegatedOutcome$1({ drawDefinition, event, matchUpId }) {
   });
 }
 
+function stringSort(a, b) {
+  return (a || "").localeCompare(b || "");
+}
+
 function generateCandidate({
   maxIterations = 4e3,
   // cap the processing intensity of the candidate generator
@@ -46857,7 +46870,7 @@ function roundCandidate({
   return { value: candidateValue, participantIdPairings, maxDelta, maxDiff };
 }
 function pairingHash(id1, id2) {
-  return [id1, id2].sort().join("|");
+  return [id1, id2].sort(stringSort).join("|");
 }
 
 function getPairingsData({ participantIds }) {
@@ -46996,8 +47009,10 @@ function getPairings({
 
 const ENCOUNTER_VALUE = 100;
 const SAME_TEAM_VALUE = 100;
-const MAX_ITERATIONS = 5e3;
+const MAX_ITERATIONS = 4e3;
 function generateDrawMaticRound({
+  encounterValue = ENCOUNTER_VALUE,
+  sameTeamValue = SAME_TEAM_VALUE,
   maxIterations = MAX_ITERATIONS,
   generateMatchUps = true,
   tournamentParticipants,
@@ -47030,7 +47045,7 @@ function generateDrawMaticRound({
   for (const pairing of encounters) {
     if (!valueObjects[pairing])
       valueObjects[pairing] = 0;
-    valueObjects[pairing] += ENCOUNTER_VALUE;
+    valueObjects[pairing] += encounterValue;
   }
   const teamParticipants = tournamentParticipants?.filter(
     ({ participantType }) => participantType === TEAM
@@ -47042,7 +47057,7 @@ function generateDrawMaticRound({
       for (const pairing of uniquePairings2) {
         if (!valueObjects[pairing])
           valueObjects[pairing] = 0;
-        valueObjects[pairing] += SAME_TEAM_VALUE;
+        valueObjects[pairing] += sameTeamValue;
       }
     }
   }
@@ -47064,7 +47079,7 @@ function generateDrawMaticRound({
     structure,
     salted
   };
-  const { candidatesCount, participantIdPairings, iterations } = getPairings(params);
+  const { candidatesCount, participantIdPairings, iterations, candidate } = getPairings(params);
   if (!candidatesCount)
     return { error: NO_CANDIDATES };
   let matchUps;
@@ -47082,12 +47097,15 @@ function generateDrawMaticRound({
       return result;
     matchUps = result.matchUps;
   }
+  const { maxDelta, maxDiff } = candidate;
   return {
     ...SUCCESS,
     participantIdPairings,
     candidatesCount,
     iterations,
-    matchUps
+    matchUps,
+    maxDelta,
+    maxDiff
   };
 }
 
@@ -47095,10 +47113,12 @@ function drawMatic$1({
   tournamentParticipants,
   restrictEntryStatus,
   adHocRatings = {},
-  tournamentRecord,
   generateMatchUps,
+  tournamentRecord,
   addToStructure,
   participantIds,
+  encounterValue,
+  sameTeamValue,
   drawDefinition,
   scaleAccessor,
   maxIterations,
@@ -47107,6 +47127,7 @@ function drawMatic$1({
   scaleName,
   // custom rating name to seed dynamic ratings
   eventType,
+  salted,
   event
 }) {
   if (typeof drawDefinition !== "object" || drawDefinition.drawType && drawDefinition.drawType !== AD_HOC) {
@@ -47172,16 +47193,19 @@ function drawMatic$1({
   }
   return generateDrawMaticRound({
     tournamentParticipants,
-    tournamentRecord,
     generateMatchUps,
-    participantIds,
+    tournamentRecord,
     addToStructure,
+    participantIds,
+    encounterValue,
+    sameTeamValue,
     drawDefinition,
     maxIterations,
     adHocRatings,
     matchUpIds,
     structure,
-    eventType
+    eventType,
+    salted
   });
 }
 function getScaleValue({
@@ -52885,6 +52909,20 @@ function setTournamentStatus({ tournamentRecord, status }) {
   return { ...SUCCESS };
 }
 
+function addOnlineResource({
+  tournamentRecord,
+  onlineResource
+}) {
+  if (!tournamentRecord)
+    return { error: MISSING_TOURNAMENT_RECORD };
+  if (!onlineResource)
+    return { error: MISSING_VALUE };
+  if (!tournamentRecord.onlineResources)
+    tournamentRecord.onlineResources = [];
+  tournamentRecord.onlineResources.push(onlineResource);
+  return { ...SUCCESS };
+}
+
 function analyzeDraws({ tournamentRecord }) {
   if (!tournamentRecord)
     return { error: MISSING_TOURNAMENT_RECORD };
@@ -53163,10 +53201,11 @@ function removeInvalidScheduling({ tournamentRecord }) {
 }
 
 const tournamentGovernor = {
-  addNotes,
-  removeNotes,
-  analyzeDraws,
   analyzeTournament,
+  analyzeDraws,
+  addOnlineResource,
+  removeNotes,
+  addNotes,
   completeDrawMatchUps,
   getRounds,
   getProfileRounds,
@@ -58215,11 +58254,9 @@ function getPredictiveAccuracy(params) {
   let { matchUps } = params;
   const {
     tournamentRecord,
-    ascending = true,
     drawDefinition,
     excludeMargin,
     exclusionRule,
-    valueAccessor,
     zoneDoubling,
     matchUpType,
     zoneMargin,
@@ -58234,6 +58271,9 @@ function getPredictiveAccuracy(params) {
     return { error: INVALID_VALUES, info: { matchUpType } };
   if (matchUps && !validMatchUps(matchUps))
     return { error: INVALID_VALUES, context: { matchUps } };
+  const scaleProfile = ratingsParameters[scaleName];
+  const ascending = scaleProfile?.ascending ?? params.ascending ?? false;
+  const valueAccessor = scaleProfile?.accessor ?? params.valueAccessor;
   const contextProfile = { withScaleValues: true, withCompetitiveness: true };
   const contextFilters = {
     matchUpTypes: matchUpType ? [matchUpType] : [SINGLES$1, DOUBLES$1]
@@ -58283,7 +58323,7 @@ function getPredictiveAccuracy(params) {
     scaleName
   });
   const marginCalc = !zoneDoubling || matchUpType === SINGLES$1 ? zoneMargin : zoneMargin * 2;
-  const zoneData = zoneMargin && relevantMatchUps.map(({ competitiveness, matchUpType: matchUpType2, score, sides }) => {
+  const zoneData = zoneMargin && relevantMatchUps.map(({ competitiveProfile, matchUpType: matchUpType2, score, sides }) => {
     const sideValues = getSideValues({
       valueAccessor,
       matchUpType: matchUpType2,
@@ -58291,7 +58331,11 @@ function getPredictiveAccuracy(params) {
       sides
     });
     const valuesGap = Math.abs(sideValues[0].value - sideValues[1].value);
-    return { competitiveness, score, valuesGap };
+    return {
+      competitiveness: competitiveProfile?.competitiveness,
+      valuesGap,
+      score
+    };
   }).filter(({ valuesGap }) => {
     return valuesGap <= marginCalc;
   });
@@ -58459,7 +58503,7 @@ function getGroupingAccuracy({
       });
       continue;
     }
-    const signedGap = ascending ? valuesGap * -1 : valuesGap;
+    const signedGap = ascending ? valuesGap : valuesGap * -1;
     const winningScoreString = winningSide === 1 ? score?.scoreStringSide1 : score?.scoreStringSide2;
     if (signedGap > 0) {
       accuracy.affirmative.push({
@@ -58533,18 +58577,14 @@ function getMatchUpFormat({
   };
 }
 
-function getMatchUpsStats({
-  competitiveProfile,
-  tournamentRecord,
-  matchUps
-}) {
+function getMatchUpsStats({ profileBands, tournamentRecord, matchUps }) {
   if (!validMatchUps(matchUps))
     return { error: MISSING_MATCHUPS };
-  const policy = !competitiveProfile && findPolicy({
+  const policy = !profileBands && findPolicy({
     policyType: POLICY_TYPE_COMPETITIVE_BANDS,
     tournamentRecord
   }).policy;
-  const bandProfiles = competitiveProfile || policy?.competitiveProfile || POLICY_COMPETITIVE_BANDS_DEFAULT[POLICY_TYPE_COMPETITIVE_BANDS].competitiveProfile;
+  const bandProfiles = profileBands || policy?.profileBands || POLICY_COMPETITIVE_BANDS_DEFAULT[POLICY_TYPE_COMPETITIVE_BANDS].profileBands;
   const relevantMatchUps = matchUps.filter(({ winningSide }) => winningSide);
   const gamesMap = relevantMatchUps.map(getScoreComponents);
   const categorize = (p, spread) => {
@@ -58733,7 +58773,7 @@ const queryGovernor = {
   getPositionAssignments,
   isValidMatchUpFormat: isValid,
   getMaxEntryPosition,
-  getMatchUpCompetitiveness,
+  getMatchUpCompetitiveProfile,
   findVenue,
   getCourts,
   getVenuesAndCourts: getVenuesAndCourts$1,