tods-competition-factory 1.7.11 → 1.7.13

package/dist/index.mjs

@@ -333,7 +333,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.7.11";
+  return "1.7.13";
 }
 
 function getObjectTieFormat(obj) {
@@ -16620,7 +16620,6 @@ function compareTieFormats({
   );
   const nameDifference = !!(considerations?.collectionName && descendant.collectionDefinitions.map(({ collectionName }) => collectionName).join("|") !== ancestor.collectionDefinitions.map(({ collectionName }) => collectionName).join("|"));
   const orderDifference = !!(considerations?.collectionOrder && descendant.collectionDefinitions.map(({ collectionOrder }) => collectionOrder).join("|") !== ancestor.collectionDefinitions.map(({ collectionOrder }) => collectionOrder).join("|"));
-  const different = nameDifference || orderDifference || ancestorDesc !== descendantDesc;
   const descendantCollectionDefinitions = Object.assign(
     {},
     ...(descendant?.collectionDefinitions || []).map(
@@ -16644,17 +16643,16 @@ function compareTieFormats({
     Object.keys(descendantCollectionDefinitions)
   );
   descendantDifferences.collectionsValue = getCollectionsValue(
-    descendantCollectionDefinitions,
-    descendantDifferences
+    descendantCollectionDefinitions
   );
   ancestorDifferences.collectionsValue = getCollectionsValue(
-    ancestorCollectionDefinitions,
-    ancestorDifferences
+    ancestorCollectionDefinitions
   );
   descendantDifferences.groupsCount = ancestor?.collectionGroups?.length ?? (0 - (descendant?.collectionGroups?.length ?? 0) || 0);
   ancestorDifferences.groupsCount = descendantDifferences.groupsCount ? -1 * descendantDifferences.groupsCount : 0;
   const valueDifference = descendantDifferences.collectionsValue.totalValue - ancestorDifferences.collectionsValue.totalValue;
   const matchUpCountDifference = descendantDifferences.collectionsValue.totalMatchUps - ancestorDifferences.collectionsValue.totalMatchUps;
+  const different = nameDifference || orderDifference || ancestorDesc !== descendantDesc || valueDifference !== 0;
   return {
     matchUpFormatDifferences,
     matchUpCountDifference,
@@ -16669,15 +16667,18 @@ function compareTieFormats({
     different
   };
 }
-function getCollectionsValue(definitions, aggregator) {
+function getCollectionsValue(definitions) {
   let totalMatchUps = 0;
-  const totalValue = aggregator.collectionIds.reduce((total, collectionId) => {
+  const collectionIds = Object.keys(definitions);
+  const totalValue = collectionIds.reduce((total, collectionId) => {
     const collectionDefinition = definitions[collectionId];
     const {
       collectionValueProfiles,
       collectionValue,
       matchUpCount,
-      matchUpValue
+      matchUpValue,
+      scoreValue,
+      setValue
     } = collectionDefinition;
     totalMatchUps += matchUpCount;
     if (collectionValueProfiles)
@@ -16685,9 +16686,16 @@ function getCollectionsValue(definitions, aggregator) {
         (total2, profile) => total2 + profile.value,
         0
       );
-    if (matchUpValue && matchUpCount)
-      return total + matchUpValue * matchUpCount;
-    return total + collectionValue;
+    if (matchUpCount) {
+      if (isConvertableInteger(matchUpValue))
+        return total + matchUpValue * matchUpCount;
+      if (isConvertableInteger(scoreValue))
+        return total + scoreValue * matchUpCount;
+      if (isConvertableInteger(setValue))
+        return total + setValue * matchUpCount;
+      return total + collectionValue;
+    }
+    return total;
   }, 0);
   return { totalValue, totalMatchUps };
 }
@@ -29561,6 +29569,7 @@ function getTieFormat$1({
   // optional - if an eventId is present only return tieFormat for event
   event
 }) {
+  const stack = "getTieFormat";
   let tieFormat;
   structureId = structure?.structureId ?? structureId;
   matchUpId = matchUp?.matchUpId ?? matchUpId;
@@ -29576,6 +29585,9 @@ function getTieFormat$1({
       });
       if (result.error)
         return result;
+      if (result.matchUp?.matchUpType !== TEAM_MATCHUP) {
+        return decorateResult({ result: { error: INVALID_MATCHUP }, stack });
+      }
       if (!structure)
         structure = result.structure;
       if (!matchUp)
@@ -29609,7 +29621,7 @@ function getTieFormat$1({
     tieFormat = getObjectTieFormat(drawDefinition) || getObjectTieFormat(event);
   }
   if (!tieFormat)
-    return decorateResult({ result: { error: MISSING_TIE_FORMAT } });
+    return decorateResult({ result: { error: MISSING_TIE_FORMAT }, stack });
   return { ...SUCCESS, tieFormat, matchUp, structure };
 }
 
@@ -29792,9 +29804,9 @@ function modifyCollectionDefinition$1({
   tournamentRecord,
   collectionOrder,
   collectionName,
+  tieFormatName,
   drawDefinition,
   matchUpFormat,
-  tieFormatName,
   matchUpCount,
   collectionId,
   matchUpType,
@@ -29811,19 +29823,35 @@ function modifyCollectionDefinition$1({
   scoreValue,
   setValue
 }) {
+  const stack = "modifyCollectionDefinition";
   if (matchUpFormat && !isValid(matchUpFormat)) {
-    return { error: INVALID_VALUES };
+    return decorateResult({
+      result: { error: INVALID_VALUES },
+      context: { matchUpFormat },
+      stack
+    });
   }
   if (collectionName && typeof collectionName !== "string") {
-    return { error: INVALID_VALUES };
+    return decorateResult({
+      result: { error: INVALID_VALUES },
+      context: { collectionName },
+      stack
+    });
   }
   if (gender && !Object.values(genderConstants).includes(gender)) {
-    return { error: INVALID_VALUES };
+    return decorateResult({
+      result: { error: INVALID_VALUES },
+      context: { gender },
+      stack
+    });
   }
   if (category && typeof category !== "object") {
-    return { error: INVALID_VALUES };
+    return decorateResult({
+      result: { error: INVALID_VALUES },
+      context: { category },
+      stack
+    });
   }
-  const stack = "modifyCollectionDefinition";
   const valueAssignments = {
     collectionValueProfiles,
     collectionValue,
@@ -29835,10 +29863,8 @@ function modifyCollectionDefinition$1({
     return decorateResult({ result: { error: MISSING_VALUE }, stack });
   if (Object.values(valueAssignments).filter(Boolean).length > 1)
     return decorateResult({
-      result: {
-        info: "Only one value assignment allowed per collectionDefinition",
-        error: INVALID_VALUES
-      },
+      info: "Only one value assignment allowed per collectionDefinition",
+      result: { error: INVALID_VALUES },
       stack
     });
   let result = getTieFormat$1({
@@ -29848,79 +29874,137 @@ function modifyCollectionDefinition$1({
     eventId,
     event
   });
-  if (result.error)
+  if (result.error) {
     return decorateResult({ result, stack });
+  }
   const { matchUp, structure, tieFormat: existingTieFormat } = result;
   const tieFormat = copyTieFormat(existingTieFormat);
-  const collectionDefinition = tieFormat.collectionDefinitions.find(
-    (collectionDefinition2) => collectionDefinition2.collectionId === collectionId
+  const sourceCollectionDefinition = existingTieFormat?.collectionDefinitions.find(
+    (collectionDefinition) => collectionDefinition.collectionId === collectionId
   );
-  if (!collectionDefinition)
+  const targetCollectionDefinition = tieFormat?.collectionDefinitions.find(
+    (collectionDefinition) => collectionDefinition.collectionId === collectionId
+  );
+  if (!sourceCollectionDefinition)
     return decorateResult({ result: { error: NOT_FOUND }, stack });
-  const value = collectionValue || matchUpValue || scoreValue || setValue;
-  if (value || collectionValueProfiles) {
-    if (value) {
-      if (!isConvertableInteger(value))
-        return decorateResult({ result: { error: INVALID_VALUES, value } });
-    } else if (collectionValueProfiles) {
-      const result2 = validateCollectionValueProfile({
-        matchUpCount: collectionDefinition.matchUpCount,
-        collectionValueProfiles
-      });
-      if (result2.errors) {
-        return decorateResult({
-          result: { error: INVALID_VALUES, info: result2.errors },
-          stack
-        });
-      }
+  const value = collectionValue ?? matchUpValue ?? scoreValue ?? setValue;
+  if (collectionValueProfiles) {
+    const result2 = validateCollectionValueProfile({
+      matchUpCount: matchUpCount || sourceCollectionDefinition?.matchUpCount,
+      collectionValueProfiles
+    });
+    if (result2.errors) {
+      return decorateResult({
+        result: { error: INVALID_VALUES },
+        info: result2.errors,
+        stack
+      });
     }
-    collectionDefinition.collectionValue = void 0;
-    collectionDefinition.matchUpValue = void 0;
-    collectionDefinition.scoreValue = void 0;
-    collectionDefinition.setValue = void 0;
-    Object.assign(collectionDefinition, valueAssignments);
+  } else if (value && !isConvertableInteger(value)) {
+    return decorateResult({
+      result: { error: INVALID_VALUES },
+      info: "value is not an integer",
+      context: { value },
+      stack
+    });
+  }
+  const equivalentValueProfiles = (a, b) => intersection(Object.keys(a), Object.keys(b)).length === Object.keys(a).length && intersection(Object.values(a), Object.values(b)).length === Object.values(a).length;
+  const valueProfileModified = collectionValueProfiles && (!sourceCollectionDefinition.collectionValueProfiles || !equivalentValueProfiles(
+    sourceCollectionDefinition.collectionValueProfiles,
+    collectionValueProfiles
+  ));
+  const valueModified = isConvertableInteger(collectionValue) && sourceCollectionDefinition.collectionValue !== collectionValue || isConvertableInteger(matchUpValue) && sourceCollectionDefinition.matchUpValue !== matchUpValue || isConvertableInteger(scoreValue) && sourceCollectionDefinition.scoreValue !== scoreValue || isConvertableInteger(setValue) && sourceCollectionDefinition.setValue !== setValue || valueProfileModified;
+  const modifications = [];
+  if (valueModified) {
+    targetCollectionDefinition.collectionValueProfiles = void 0;
+    targetCollectionDefinition.collectionValue = void 0;
+    targetCollectionDefinition.matchUpValue = void 0;
+    targetCollectionDefinition.scoreValue = void 0;
+    targetCollectionDefinition.setValue = void 0;
+    Object.assign(targetCollectionDefinition, valueAssignments);
+    modifications.push({
+      collectionId,
+      ...definedAttributes(valueAssignments)
+    });
   }
-  if ((scoreValue || setValue) && collectionDefinition.collectionGroupNumber) {
-    const targetCollectionGroupNumber = collectionDefinition.collectionGroupNumber;
+  if ((isConvertableInteger(scoreValue) || isConvertableInteger(setValue)) && targetCollectionDefinition.collectionGroupNumber) {
+    const targetCollectionGroupNumber = targetCollectionDefinition.collectionGroupNumber;
     tieFormat.collectionDefinitions = tieFormat.collectionDefinitions.map(
-      (collectionDefinition2) => {
-        const { collectionGroupNumber, ...rest } = collectionDefinition2;
+      (collectionDefinition) => {
+        const { collectionGroupNumber, ...rest } = collectionDefinition;
         if (collectionGroupNumber === targetCollectionGroupNumber) {
           return rest;
         } else {
-          return collectionDefinition2;
+          return collectionDefinition;
         }
       }
     );
     tieFormat.collectionGroups = tieFormat.collectionGroups.filter(
       ({ groupNumber }) => groupNumber !== targetCollectionGroupNumber
     );
+    modifications.push({
+      collectionId,
+      change: "collectionGroupNumber removed"
+    });
   }
   const { aggregateValue, valueGoal } = calculateWinCriteria(tieFormat);
-  tieFormat.winCriteria = definedAttributes({ aggregateValue, valueGoal });
-  const originalValueGoal = existingTieFormat?.winCriteria.valueGoal;
-  const wasAggregateValue = existingTieFormat?.winCriteria.aggregateValue;
-  if (originalValueGoal && originalValueGoal !== valueGoal || aggregateValue && !wasAggregateValue) {
-    delete tieFormat.tieFormatName;
-  }
-  if (tieFormatName)
-    tieFormat.tieFormatName = tieFormatName;
-  if (collectionOrder)
-    collectionDefinition.collectionOrder = collectionOrder;
-  if (collectionName)
-    collectionDefinition.collectionName = collectionName;
-  if (matchUpFormat)
-    collectionDefinition.matchUpFormat = matchUpFormat;
-  if (matchUpType)
-    collectionDefinition.matchUpType = matchUpType;
-  if (category)
-    collectionDefinition.category = category;
-  if (gender)
-    collectionDefinition.gender = gender;
+  const winCriteria = definedAttributes({ aggregateValue, valueGoal });
+  if (winCriteria.aggregateValue !== existingTieFormat?.winCriteria.aggregateValue || winCriteria.valueGoal !== existingTieFormat?.winCriteria.valueGoal) {
+    tieFormat.winCriteria = winCriteria;
+    modifications.push({ collectionId, winCriteria });
+  }
+  if (isConvertableInteger(collectionOrder) && sourceCollectionDefinition.collectionOrder !== collectionOrder) {
+    targetCollectionDefinition.collectionOrder = collectionOrder;
+    modifications.push({ collectionId, collectionOrder });
+  }
+  if (collectionName && sourceCollectionDefinition.collectionName !== collectionName) {
+    targetCollectionDefinition.collectionName = collectionName;
+    modifications.push({ collectionId, collectionName });
+  }
+  if (matchUpFormat && sourceCollectionDefinition.matchUpFormat !== matchUpFormat) {
+    targetCollectionDefinition.matchUpFormat = matchUpFormat;
+    modifications.push({ collectionId, matchUpFormat });
+  }
+  if (isConvertableInteger(matchUpCount) && sourceCollectionDefinition.matchUpCount !== matchUpCount) {
+    return decorateResult({
+      result: { error: NOT_IMPLEMENTED },
+      context: { matchUpCount },
+      stack
+    });
+  }
+  if (matchUpType && sourceCollectionDefinition.matchUpType !== matchUpType) {
+    return decorateResult({
+      result: { error: NOT_IMPLEMENTED },
+      context: { matchUpType },
+      stack
+    });
+  }
+  if (category && sourceCollectionDefinition.category !== category) {
+    targetCollectionDefinition.category = category;
+    modifications.push({ collectionId, category });
+  }
+  if (gender && sourceCollectionDefinition.gender !== gender) {
+    targetCollectionDefinition.gender = gender;
+    modifications.push({ collectionId, gender });
+  }
   const prunedTieFormat = definedAttributes(tieFormat);
   result = validateTieFormat({ tieFormat: prunedTieFormat });
-  if (result.error)
+  if (result.error) {
     return decorateResult({ result, stack });
+  }
+  if (!modifications.length) {
+    return decorateResult({ result: { ...SUCCESS, modifications } });
+  }
+  const changedTieFormatName = existingTieFormat?.tieFormatName !== tieFormatName;
+  if (changedTieFormatName) {
+    prunedTieFormat.tieFormatName = tieFormatName;
+    modifications.push({ tieFormatName });
+  } else if (modifications.length) {
+    delete prunedTieFormat.tieFormatName;
+    modifications.push(
+      "tieFormatName removed: modifications without new tieFormatName"
+    );
+  }
   result = updateTieFormat({
     tieFormat: prunedTieFormat,
     updateInProgressMatchUps,
@@ -29935,8 +30019,8 @@ function modifyCollectionDefinition$1({
     const { appliedPolicies } = getAppliedPolicies({ tournamentRecord });
     if (appliedPolicies?.audit?.[TIE_FORMAT_MODIFICATIONS]) {
       const auditData = definedAttributes({
+        collectionDefinition: targetCollectionDefinition,
         drawId: drawDefinition?.drawId,
-        collectionDefinition,
         action: stack,
         structureId,
         matchUpId,
@@ -29945,7 +30029,7 @@ function modifyCollectionDefinition$1({
       tieFormatTelemetry({ drawDefinition, auditData });
     }
   }
-  return decorateResult({ result, stack });
+  return decorateResult({ result: { ...result, modifications }, stack });
 }
 
 function resolveTournamentRecord(params) {
@@ -30440,10 +30524,10 @@ function addCollectionDefinition$1({
       ({ collectionId }) => collectionId
     );
     if (collectionIds.includes(collectionDefinition.collectionId))
-      return {
-        collectionId: collectionDefinition.collectionId,
-        error: DUPLICATE_VALUE
-      };
+      return decorateResult({
+        context: { collectionId: collectionDefinition.collectionId },
+        result: { error: DUPLICATE_VALUE }
+      });
   }
   tieFormat.collectionDefinitions.push(collectionDefinition);
   tieFormat.collectionDefinitions.sort((a, b) => (a.collectionOrder || 0) - (b.collectionOrder || 0)).forEach(
@@ -30516,7 +30600,10 @@ function addCollectionDefinition$1({
     });
   } else if (matchUpId && matchUp) {
     if (!validUpdate({ matchUp, updateInProgressMatchUps }))
-      return { error: CANNOT_MODIFY_TIEFORMAT };
+      return decorateResult({
+        result: { error: CANNOT_MODIFY_TIEFORMAT },
+        stack
+      });
     matchUp.tieFormat = prunedTieFormat;
     const newMatchUps = generateCollectionMatchUps({
       collectionDefinition,
@@ -30571,10 +30658,10 @@ function addCollectionDefinition$1({
     tieFormatTelemetry({ drawDefinition, auditData });
   }
   return {
-    ...SUCCESS,
     tieFormat: prunedTieFormat,
     targetMatchUps,
-    addedMatchUps
+    addedMatchUps,
+    ...SUCCESS
   };
 }
 function updateStructureMatchUps({
@@ -31105,45 +31192,42 @@ function modifyTieFormat$1({
     return decorateResult({ result, stack });
   const { matchUp, tieFormat: existingTieFormat } = result;
   const tieFormat = copyTieFormat(existingTieFormat);
+  if (!compareTieFormats({ ancestor: tieFormat, descendant: modifiedTieFormat })?.different) {
+    return { ...SUCCESS };
+  }
   const existingCollectionIds = tieFormat.collectionDefinitions.map(
     ({ collectionId }) => collectionId
   );
-  const modifiedCollectionDefinitions = [];
-  const addedCollectionDefinitions = [];
-  const updatedCollectionIds = [];
-  modifiedTieFormat.collectionDefinitions.forEach((def) => {
-    updatedCollectionIds.push(def.collectionId);
-    if (modifiedTieFormat && existingCollectionIds.includes(def.collectionId)) {
-      compareTieFormats({
-        descendant: modifiedTieFormat,
-        ancestor: tieFormat
-      })?.different && modifiedCollectionDefinitions.push(def);
-    } else {
-      addedCollectionDefinitions.push(def);
-    }
-  });
+  const updatedCollectionIds = modifiedTieFormat.collectionDefinitions.map(
+    ({ collectionId }) => collectionId
+  );
   const removedCollectionIds = existingCollectionIds.filter(
     (collectionId) => !updatedCollectionIds.includes(collectionId)
   );
-  const tieFormatName = modifiedTieFormat.tieFormatName;
+  const addedCollectionDefinitions = modifiedTieFormat.collectionDefinitions.filter(
+    ({ collectionId }) => !existingCollectionIds.includes(collectionId)
+  );
+  const modifications = [];
   let processedTieFormat;
-  for (const collectionDefinition of modifiedCollectionDefinitions) {
+  for (const collectionDefinition of modifiedTieFormat.collectionDefinitions) {
     const result2 = modifyCollectionDefinition$1({
       updateInProgressMatchUps,
       ...collectionDefinition,
       tournamentRecord,
       drawDefinition,
-      tieFormatName,
       structureId,
       matchUpId,
       eventId,
       event
     });
+    if (result2.modifications)
+      modifications.push(...result2.modifications);
     if (result2.error)
       return decorateResult({ result: result2, stack });
     if (result2.tieFormat)
       processedTieFormat = result2.tieFormat;
   }
+  const tieFormatName = modifiedTieFormat.tieFormatName;
   for (const collectionDefinition of addedCollectionDefinitions) {
     const result2 = addCollectionDefinition$1({
       updateInProgressMatchUps,
@@ -31182,10 +31266,20 @@ function modifyTieFormat$1({
     if (result2.tieFormat)
       processedTieFormat = result2.tieFormat;
   }
+  const changedTieFormatName = existingTieFormat?.tieFormatName !== tieFormatName;
+  if (changedTieFormatName) {
+    processedTieFormat.tieFormatName = tieFormatName;
+    modifications.push({ tieFormatName });
+  } else if (modifications.length) {
+    delete processedTieFormat.tieFormatName;
+    modifications.push(
+      "tieFormatName removed: modifications without new tieFormatName"
+    );
+  }
   processedTieFormat.collectionDefinitions = processedTieFormat.collectionDefinitions.sort(
     (a, b) => numericSortValue(a.collectionOrder) - numericSortValue(b.collectionOrder)
   ).map((def, i) => ({ ...def, collectionOrder: i + 1 }));
-  return { ...SUCCESS, processedTieFormat };
+  return { ...SUCCESS, processedTieFormat, modifications };
 }
 
 function modifyTieFormat(params) {
@@ -60246,6 +60340,7 @@ var lastNames = [
 	"Dallas",
 	"Diamond",
 	"Deckard",
+	"Dunbar",
 	"Earhart",
 	"Eisenstein",
 	"Eldritch",