tods-competition-factory 1.8.25 → 1.8.27

package/dist/forge/generate.d.ts

@@ -1601,7 +1601,9 @@ type AutomatedPositioningArgs = {
 };
 declare function automatedPositioning({ applyPositioning, tournamentRecord, drawDefinition, seedingProfile, structureId, placeByes, seedsOnly, drawSize, event, }: AutomatedPositioningArgs): (ResultType & {
     positionAssignments?: PositionAssignment[] | undefined;
-    positioningReport?: any;
+    positioningReport?: {
+        [key: string]: any;
+    } | undefined;
     success?: boolean | undefined;
     conflicts?: any[] | undefined;
 }) | {
@@ -1627,6 +1629,9 @@ type AutomatedPlayoffPositioningArgs = {
 };
 declare function automatedPlayoffPositioning(params: AutomatedPlayoffPositioningArgs): {
     structurePositionAssignments?: StructurePositionAssignmentType[];
+    positioningReports?: {
+        [key: string]: any;
+    }[];
     success?: boolean;
     error?: ErrorType;
 };

package/dist/forge/generate.mjs

@@ -846,18 +846,21 @@ function cycleMutationStatus() {
   return status;
 }
 function addNotice$1({ topic, payload, key }) {
-  syncGlobalState.modified = true;
   if (typeof topic !== "string" || typeof payload !== "object") {
     return;
   }
-  if (syncGlobalState.disableNotifications || !syncGlobalState.subscriptions[topic])
+  if (!syncGlobalState.disableNotifications)
+    syncGlobalState.modified = true;
+  if (syncGlobalState.disableNotifications || !syncGlobalState.subscriptions[topic]) {
     return;
+  }
   if (key) {
     syncGlobalState.notices = syncGlobalState.notices.filter(
       (notice) => !(notice.topic === topic && notice.key === key)
     );
   }
   syncGlobalState.notices.push({ topic, payload, key });
+  return { ...SUCCESS };
 }
 function getNotices({ topic }) {
   const notices = syncGlobalState.notices.filter((notice) => notice.topic === topic).map((notice) => notice.payload);
@@ -1449,6 +1452,7 @@ const POLICY_TYPE_MATCHUP_ACTIONS = "matchUpActions";
 const POLICY_TYPE_ROUND_NAMING = "roundNaming";
 const POLICY_TYPE_PARTICIPANT = "participant";
 const POLICY_TYPE_SCHEDULING = "scheduling";
+const POLICY_TYPE_AVOIDANCE = "avoidance";
 const POLICY_TYPE_DISPLAY = "display";
 const POLICY_TYPE_SCORING = "scoring";
 const POLICY_TYPE_SEEDING = "seeding";
@@ -3100,41 +3104,6 @@ function getMatchUpType(params) {
   return { matchUpType };
 }
 
-function modifyEntryProfile({
-  drawDefinition,
-  attributes
-}) {
-  let { extension } = findDrawDefinitionExtension({
-    name: ENTRY_PROFILE,
-    drawDefinition
-  });
-  const entryProfile = extension?.value || {};
-  attributes.forEach((attribute) => {
-    Object.keys(attribute).forEach((key) => {
-      if (!entryProfile[key]) {
-        entryProfile[key] = attribute[key];
-      } else {
-        Object.assign(entryProfile[key], attribute[key]);
-      }
-    });
-  });
-  extension = {
-    name: ENTRY_PROFILE,
-    value: entryProfile
-  };
-  addDrawDefinitionExtension({ drawDefinition, extension });
-  return { entryProfile };
-}
-
-function getEntryProfile({ drawDefinition }) {
-  const { extension } = findDrawDefinitionExtension({
-    name: ENTRY_PROFILE,
-    drawDefinition
-  });
-  const entryProfile = extension?.value || {};
-  return { entryProfile };
-}
-
 const MAIN = "MAIN";
 const QUALIFYING = "QUALIFYING";
 const CONSOLATION = "CONSOLATION";
@@ -3328,6 +3297,118 @@ function getDrawStructures({
   }
 }
 
+function getAllPositionedParticipantIds({
+  drawDefinition
+}) {
+  if (!drawDefinition)
+    return { error: MISSING_DRAW_DEFINITION };
+  const stagePositionedParticipantIds = {};
+  const allPositionedParticipantIds = (drawDefinition.structures || []).map((structure) => {
+    const stage = structure.stage;
+    if (!stagePositionedParticipantIds[stage])
+      stagePositionedParticipantIds[stage] = [];
+    const { positionAssignments } = getPositionAssignments({ structure });
+    const particiapntIds = positionAssignments?.map(extractAttributes("participantId")).filter(Boolean) ?? [];
+    stagePositionedParticipantIds[stage].push(...particiapntIds);
+    return particiapntIds;
+  }).flat();
+  return { allPositionedParticipantIds, stagePositionedParticipantIds };
+}
+function getPositionAssignments({
+  drawDefinition,
+  structureId,
+  structure
+}) {
+  let error, positionAssignments = [];
+  if (!structure) {
+    if (!drawDefinition) {
+      return { positionAssignments, error: MISSING_DRAW_DEFINITION };
+    }
+    ({ structure, error } = findStructure({ drawDefinition, structureId }));
+    if (error)
+      return { positionAssignments, error };
+  }
+  if (structure.structures) {
+    positionAssignments = [].concat(
+      ...structure.structures.map((structure2) => {
+        return getPositionAssignments({ structure: structure2 }).positionAssignments;
+      })
+    );
+  } else if (structure.positionAssignments) {
+    positionAssignments = structure.positionAssignments;
+  } else {
+    error = MISSING_POSITION_ASSIGNMENTS;
+  }
+  return { positionAssignments, error };
+}
+function structureAssignedDrawPositions({
+  drawDefinition,
+  structureId,
+  structure
+}) {
+  const positionAssignments = getPositionAssignments({
+    drawDefinition,
+    structureId,
+    structure
+  })?.positionAssignments || [];
+  const assignedPositions = positionAssignments?.filter((assignment) => {
+    return assignment.participantId ?? assignment.bye ?? assignment.qualifier;
+  });
+  const allPositionsAssigned = positionAssignments && positionAssignments?.length === assignedPositions?.length;
+  const unassignedPositions = positionAssignments?.filter((assignment) => {
+    return !assignment.participantId && !assignment.bye && !assignment.qualifier;
+  });
+  const byePositions = positionAssignments?.filter((assignment) => {
+    return !assignment.participantId && assignment.bye;
+  });
+  const qualifierPositions = positionAssignments?.filter((assignment) => {
+    return !assignment.participantId && assignment.qualifier;
+  });
+  return {
+    allPositionsAssigned,
+    positionAssignments,
+    unassignedPositions,
+    assignedPositions,
+    qualifierPositions,
+    byePositions
+  };
+}
+
+function modifyEntryProfile({
+  drawDefinition,
+  attributes
+}) {
+  let { extension } = findDrawDefinitionExtension({
+    name: ENTRY_PROFILE,
+    drawDefinition
+  });
+  const entryProfile = extension?.value || {};
+  attributes.forEach((attribute) => {
+    Object.keys(attribute).forEach((key) => {
+      if (!entryProfile[key]) {
+        entryProfile[key] = attribute[key];
+      } else {
+        Object.assign(entryProfile[key], attribute[key]);
+      }
+    });
+  });
+  extension = {
+    name: ENTRY_PROFILE,
+    value: entryProfile
+  };
+  addDrawDefinitionExtension({ drawDefinition, extension });
+  return { entryProfile };
+}
+
+function getEntryProfile({ drawDefinition }) {
+  const { extension } = findDrawDefinitionExtension({
+    name: ENTRY_PROFILE,
+    drawDefinition
+  });
+  const entryProfile = extension?.value || {};
+  return { entryProfile };
+}
+
 const ALTERNATE = EntryStatusEnum.Alternate;
 const CONFIRMED = EntryStatusEnum.Confirmed;
 const DIRECT_ACCEPTANCE = EntryStatusEnum.DirectAcceptance;
@@ -3515,6 +3596,7 @@ function getStageDirectEntriesCount({ stage, drawDefinition }) {
 
 function getStructureSeedAssignments({
   provisionalPositioning,
+  returnAllProxies,
   drawDefinition,
   structureId,
   structure
@@ -3523,6 +3605,9 @@ function getStructureSeedAssignments({
   if (!structure) {
     ({ structure, error } = findStructure({ drawDefinition, structureId }));
   }
+  const positionAssignments = getPositionAssignments({
+    structure
+  }).positionAssignments;
   if (error || !structure)
     return { seedAssignments: [], error: STRUCTURE_NOT_FOUND };
   if (!structureId)
@@ -3536,18 +3621,22 @@ function getStructureSeedAssignments({
     structureId,
     stage
   });
-  const seedProxies = entries ? entries.filter((entry) => entry.placementGroup === 1).sort((a, b) => {
+  const proxiedEntries = entries ? entries.filter((entry) => entry.placementGroup === 1).sort((a, b) => {
     return a.GEMscore < b.GEMscore && 1 || a.GEMscore > b.GEMscore && -1 || 0;
   }).map((entry, index) => {
     const seedNumber = index + 1;
     return {
       participantId: entry.participantId,
       seedValue: seedNumber,
-      seedNumber,
-      seedProxy: true
+      seedProxy: true,
       // flag so that proxy seeding information doesn't get used externally
+      seedNumber
     };
   }) : [];
+  const seedProxies = proxiedEntries?.slice(
+    0,
+    returnAllProxies ? proxiedEntries.length : positionAssignments.length / 2
+  );
   if (seedProxies.length) {
     seedAssignments = seedProxies;
   } else if (structure.seedAssignments) {
@@ -3556,7 +3645,13 @@ function getStructureSeedAssignments({
     error = MISSING_SEED_ASSIGNMENTS;
   }
   const seedLimit = structure.seedLimit || structure?.positionAssignments?.length;
-  return { seedAssignments, seedLimit, stage, stageSequence, error };
+  return {
+    seedAssignments,
+    stageSequence,
+    seedLimit,
+    stage,
+    error
+  };
 }
 
 function getExitProfiles({ drawDefinition }) {
@@ -3835,83 +3930,6 @@ function getSourceDrawPositionRanges({
   return { sourceDrawPositionRanges };
 }
 
-function getAllPositionedParticipantIds({
-  drawDefinition
-}) {
-  if (!drawDefinition)
-    return { error: MISSING_DRAW_DEFINITION };
-  const stagePositionedParticipantIds = {};
-  const allPositionedParticipantIds = (drawDefinition.structures || []).map((structure) => {
-    const stage = structure.stage;
-    if (!stagePositionedParticipantIds[stage])
-      stagePositionedParticipantIds[stage] = [];
-    const { positionAssignments } = getPositionAssignments({ structure });
-    const particiapntIds = positionAssignments?.map(extractAttributes("participantId")).filter(Boolean) ?? [];
-    stagePositionedParticipantIds[stage].push(...particiapntIds);
-    return particiapntIds;
-  }).flat();
-  return { allPositionedParticipantIds, stagePositionedParticipantIds };
-}
-function getPositionAssignments({
-  drawDefinition,
-  structureId,
-  structure
-}) {
-  let error, positionAssignments = [];
-  if (!structure) {
-    if (!drawDefinition) {
-      return { positionAssignments, error: MISSING_DRAW_DEFINITION };
-    }
-    ({ structure, error } = findStructure({ drawDefinition, structureId }));
-    if (error)
-      return { positionAssignments, error };
-  }
-  if (structure.structures) {
-    positionAssignments = [].concat(
-      ...structure.structures.map((structure2) => {
-        return getPositionAssignments({ structure: structure2 }).positionAssignments;
-      })
-    );
-  } else if (structure.positionAssignments) {
-    positionAssignments = structure.positionAssignments;
-  } else {
-    error = MISSING_POSITION_ASSIGNMENTS;
-  }
-  return { positionAssignments, error };
-}
-function structureAssignedDrawPositions({
-  drawDefinition,
-  structureId,
-  structure
-}) {
-  const positionAssignments = getPositionAssignments({
-    drawDefinition,
-    structureId,
-    structure
-  })?.positionAssignments || [];
-  const assignedPositions = positionAssignments?.filter((assignment) => {
-    return assignment.participantId ?? assignment.bye ?? assignment.qualifier;
-  });
-  const allPositionsAssigned = positionAssignments && positionAssignments?.length === assignedPositions?.length;
-  const unassignedPositions = positionAssignments?.filter((assignment) => {
-    return !assignment.participantId && !assignment.bye && !assignment.qualifier;
-  });
-  const byePositions = positionAssignments?.filter((assignment) => {
-    return !assignment.participantId && assignment.bye;
-  });
-  const qualifierPositions = positionAssignments?.filter((assignment) => {
-    return !assignment.participantId && assignment.qualifier;
-  });
-  return {
-    allPositionsAssigned,
-    positionAssignments,
-    unassignedPositions,
-    assignedPositions,
-    qualifierPositions,
-    byePositions
-  };
-}
-
 function getOrderedDrawPositions({
   drawPositions,
   roundProfile,
@@ -5393,6 +5411,7 @@ function getSeedGroups({
 
 function getValidSeedBlocks({
   provisionalPositioning,
+  returnAllProxies,
   appliedPolicies,
   drawDefinition,
   allPositions,
@@ -5408,6 +5427,7 @@ function getValidSeedBlocks({
   });
   const { seedAssignments } = getStructureSeedAssignments({
     provisionalPositioning,
+    returnAllProxies,
     drawDefinition,
     structure
   });
@@ -5642,6 +5662,7 @@ function getNextSeedBlock(params) {
   } = params;
   const { structure } = findStructure({ drawDefinition, structureId });
   const { seedAssignments } = getStructureSeedAssignments({
+    returnAllProxies: params.returnAllProxies,
     provisionalPositioning,
     drawDefinition,
     structure
@@ -5653,6 +5674,7 @@ function getNextSeedBlock(params) {
   const assignedDrawPositions = positionsWithParticipants?.map((assignment) => assignment.drawPosition).filter(Boolean);
   const { appliedPolicies } = getAppliedPolicies({ drawDefinition });
   const validSeedBlocks = seedBlockInfo?.validSeedBlocks || structure && getValidSeedBlocks({
+    returnAllProxies: params.returnAllProxies,
     provisionalPositioning,
     appliedPolicies,
     drawDefinition,
@@ -10010,6 +10032,48 @@ function assignFedDrawPositionBye({
   }
 }
 
+function processAccessors({
+  significantCharacters,
+  accessors = [],
+  value
+}) {
+  const extractedValues = [];
+  const accessor = accessors[0];
+  if (value?.[accessor]) {
+    const remainingKeys = accessors.slice(1);
+    if (Array.isArray(value[accessor])) {
+      const values = value[accessor];
+      values.forEach((nestedValue) => {
+        const result = processAccessors({
+          accessors: remainingKeys,
+          significantCharacters,
+          value: nestedValue
+        });
+        extractedValues.push(...result);
+      });
+    } else {
+      value = value[accessor];
+      if (remainingKeys.length) {
+        const result = processAccessors({
+          accessors: remainingKeys,
+          significantCharacters,
+          value
+        });
+        extractedValues.push(...result);
+      } else {
+        checkValue({ value });
+      }
+    }
+  }
+  function checkValue({ value: value2 }) {
+    if (value2 && ["string", "number"].includes(typeof value2)) {
+      const extractedValue = significantCharacters ? value2.slice(0, significantCharacters) : value2;
+      extractedValues.push(extractedValue);
+    }
+  }
+  return extractedValues;
+}
+
 function getAttributeGroupings({
   targetParticipantIds,
   policyAttributes,
@@ -10061,8 +10125,14 @@ function extractAttributeValues({
   policyAttributes.forEach((policyAttribute) => {
     const { directive, groupings, key, significantCharacters } = policyAttribute || {};
     if (key) {
-      const keys = key.split(".");
-      processKeys({ value: participant, keys, significantCharacters });
+      const accessors = key.split(".");
+      extractedValues.push(
+        ...processAccessors({
+          significantCharacters,
+          value: participant,
+          accessors
+        })
+      );
     } else if (directive) {
       const includeIds = policyAttribute?.includeIds;
       const collectionIds = (idCollections?.[directive] || []).filter(
@@ -10091,32 +10161,6 @@ function extractAttributeValues({
   });
   const values = unique(extractedValues);
   return { values };
-  function processKeys({ value, keys = [], significantCharacters }) {
-    for (const [index, key] of keys.entries()) {
-      if (value?.[key]) {
-        if (Array.isArray(value[key])) {
-          const values2 = value[key];
-          const remainingKeys = keys.slice(index);
-          values2.forEach(
-            (nestedValue) => processKeys({
-              value: nestedValue,
-              keys: remainingKeys,
-              significantCharacters
-            })
-          );
-        } else {
-          value = value[key];
-          checkValue({ value, index });
-        }
-      }
-    }
-    function checkValue({ value: value2, index }) {
-      if (value2 && index === keys.length - 1 && ["string", "number"].includes(typeof value2)) {
-        const extractedValue = significantCharacters ? value2.slice(0, significantCharacters) : value2;
-        extractedValues.push(extractedValue);
-      }
-    }
-  }
 }
 
 function getPositionedParticipants({
@@ -10771,10 +10815,11 @@ function updateMatchUpStatusCodes({
     );
     matchUp.matchUpStatusCodes = (matchUp.matchUpStatusCodes ?? []).map(
       (code) => {
-        if (code.sideNumber === sourceSideNumber) {
-          return { ...code, previousMatchUpStatus: sourceMatchUpStatus };
+        const value = isString(code) || !isNaN(code) ? { code } : code;
+        if (value.sideNumber === sourceSideNumber) {
+          return { ...value, previousMatchUpStatus: sourceMatchUpStatus };
         }
-        return code;
+        return value;
       }
     );
   }
@@ -11934,8 +11979,7 @@ function randomUnseededSeparation({
   structureId,
   avoidance,
   drawSize,
-  entries,
-  // entries for the specific stage of drawDefinition
+  // entries, // entries for the specific stage of drawDefinition
   event
 }) {
   if (!avoidance) {
@@ -11973,10 +12017,11 @@ function randomUnseededSeparation({
   const isRoundRobin = structure?.structureType === CONTAINER;
   const params = isRoundRobin ? { structure, matchUps, allDrawPositions, roundsToSeparate } : { matchUps, allDrawPositions, roundsToSeparate };
   const { drawPositionGroups, drawPositionChunks } = isRoundRobin ? roundRobinParticipantGroups(params) : eliminationParticipantGroups(params);
-  const idCollections = {};
-  idCollections.groupParticipants = participants.filter((participant) => participant.participantType === GROUP).map((participant) => participant.participantId);
-  idCollections.teamParticipants = participants.filter((participant) => participant.participantType === TEAM).map((participant) => participant.participantId);
-  idCollections.pairParticipants = participants.filter((participant) => participant.participantType === PAIR).map((participant) => participant.participantId);
+  const idCollections = {
+    groupParticipants: participants.filter((participant) => participant.participantType === GROUP).map((participant) => participant.participantId),
+    teamParticipants: participants.filter((participant) => participant.participantType === TEAM).map((participant) => participant.participantId),
+    pairParticipants: participants.filter((participant) => participant.participantType === PAIR).map((participant) => participant.participantId)
+  };
   const allGroups = getAttributeGroupings({
     targetParticipantIds: unseededParticipantIds,
     policyAttributes,
@@ -12037,8 +12082,8 @@ function randomUnseededSeparation({
         policyAttributes,
         idCollections,
         allGroups,
-        drawSize,
-        entries
+        drawSize
+        // entries,
       })
     );
     const candidates = noPairPriorityCandidates.concat(...pairedPriorityCandidates).filter((candidate2) => !candidate2.errors?.length);
@@ -12185,7 +12230,7 @@ function positionUnseededParticipants({
     drawDefinition,
     event
   });
-  let { avoidance } = appliedPolicies ?? {};
+  let avoidance = (appliedPolicies ?? {})[POLICY_TYPE_AVOIDANCE];
   if (structure.stage === PLAY_OFF) {
     const groupings = entries.reduce((groupings2, entry) => {
       if (!groupings2[entry.groupingValue])
@@ -12471,11 +12516,11 @@ function getSeedOrderByePositions({
   const strictSeedOrderByePositions = getOrderedByePositions({
     orderedSeedDrawPositions: orderedSortedFirstRoundSeededDrawPositions,
     relevantMatchUps
-  }).slice(0, positionedSeeds.length);
+  }).slice(0, byesToPlace);
   const blockSeedOrderByePositions = getOrderedByePositions({
     orderedSeedDrawPositions: blockSortedRandomDrawPositions,
     relevantMatchUps
-  }).slice(0, positionedSeeds.length);
+  }).slice(0, byesToPlace);
   return {
     strictSeedOrderByePositions,
     blockSeedOrderByePositions,
@@ -13157,7 +13202,6 @@ function automatedPositioning$1({
       event
     }) : void 0;
     if (result2?.error) {
-      console.log("positionByes", { result: result2 });
       return handleErrorCondition(result2);
     }
     unseededByePositions = result2?.unseededByePositions;
@@ -13315,6 +13359,7 @@ function automatedPlayoffPositioning(params) {
   );
   const structurePositionAssignments = [];
   const participants = tournamentRecord?.participants;
+  const positioningReports = [];
   if (playoffStructures) {
     for (const structure of playoffStructures) {
       const { structureId: playoffStructureId } = structure;
@@ -13336,9 +13381,11 @@ function automatedPlayoffPositioning(params) {
           structureId: playoffStructureId
         });
       }
+      if (result.positioningReport)
+        positioningReports.push(result.positioningReport);
     }
   }
-  return { ...SUCCESS, structurePositionAssignments };
+  return { ...SUCCESS, structurePositionAssignments, positioningReports };
 }
 
 function getStructureRoundProfile({
@@ -16296,6 +16343,29 @@ function ensureSideLineUps({
   }
 }
 
+function genderValidityCheck({
+  referenceGender,
+  matchUpType,
+  gender
+}) {
+  const stack = "genderValidityCheck";
+  if (referenceGender && gender && [GenderEnum.Male, GenderEnum.Female].includes(referenceGender) && [GenderEnum.Male, GenderEnum.Female].includes(gender)) {
+    const valid = gender === referenceGender;
+    return valid ? { valid: true } : decorateResult({
+      result: { valid: false, error: INVALID_GENDER },
+      context: { gender },
+      stack
+    });
+  }
+  if (matchUpType === TypeEnum.Singles && referenceGender === MIXED)
+    return decorateResult({
+      info: "matchUpType SINGLES is invalid for gender MIXED",
+      result: { error: INVALID_GENDER, valid: false },
+      stack
+    });
+  return { valid: true };
+}
+
 const typeMatch = (arr, type) => arr.filter(Boolean).every((i) => typeof i === type);
 const allNumeric = (arr) => arr.filter(Boolean).every(isNumeric);
 function getCategoryAgeDetails(params) {
@@ -16785,13 +16855,19 @@ function validateCollectionDefinition({
   if (matchUpFormat && !matchUpFormatCode.isValid(matchUpFormat)) {
     errors.push(`Invalid matchUpFormat: ${matchUpFormat}`);
   }
-  if (checkGender && referenceGender && gender && [GenderEnum.Male, GenderEnum.Female].includes(referenceGender) && referenceGender !== gender) {
-    errors.push(`Invalid gender: ${gender}`);
-    return decorateResult({
-      result: { error: INVALID_GENDER, errors },
-      context: { referenceGender, gender },
-      stack
+  if (checkGender) {
+    const result = genderValidityCheck({
+      referenceGender,
+      matchUpType,
+      gender
     });
+    if (result.error) {
+      return decorateResult({
+        context: { referenceGender, gender },
+        result,
+        stack
+      });
+    }
   }
   if (checkCategory && referenceCategory && category) {
     const result = categoryCanContain({