tods-competition-factory 0.86.3 → 0.88.2

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

@@ -249,7 +249,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return '0.86.3';
+  return '0.88.2';
 }
 
 const FORMAT_STANDARD = 'SET3-S:6/TB7'; // Best of 3 Tiebreak Sets to 6
@@ -7628,7 +7628,7 @@ var tieFormatName$3 = "USTA_INTERSECTIONAL";
 var winCriteria$3 = {
 	valueGoal: 8
 };
-var USTA_INTERSECTIONAL$1 = {
+var USTA_INTERSECTIONAL_TIE_FORMAT = {
 	collectionDefinitions: collectionDefinitions$3,
 	tieFormatName: tieFormatName$3,
 	winCriteria: winCriteria$3
@@ -7668,7 +7668,7 @@ var tieFormatName$2 = "USTA_LEVEL_1";
 var winCriteria$2 = {
 	valueGoal: 10
 };
-var USTA_LEVEL_1$1 = {
+var USTA_LEVEL_1_TIE_FORMAT = {
 	collectionDefinitions: collectionDefinitions$2,
 	tieFormatName: tieFormatName$2,
 	winCriteria: winCriteria$2
@@ -7701,7 +7701,7 @@ var tieFormatName$1 = "USTA_SOUTHERN_LEVEL_5";
 var winCriteria$1 = {
 	valueGoal: 8
 };
-var USTA_SOUTHERN_LEVEL_5$1 = {
+var USTA_SOUTHERN_LEVEL_5_TIE_FORMAT = {
 	collectionDefinitions: collectionDefinitions$1,
 	tieFormatName: tieFormatName$1,
 	winCriteria: winCriteria$1
@@ -7748,7 +7748,7 @@ var tieFormatName = "USTA_ZONAL";
 var winCriteria = {
 	valueGoal: 10
 };
-var USTA_ZONAL$1 = {
+var USTA_ZONAL_TIE_FORMAT = {
 	collectionDefinitions: collectionDefinitions,
 	tieFormatName: tieFormatName,
 	winCriteria: winCriteria
@@ -7761,10 +7761,10 @@ const tieFormats = {
   DOMINANT_DUO: DOMINANT_DUO_TIE_FORMAT,
   LAVER_CUP: LAVER_CUP_TIE_FORMAT,
   TEAM_DOUBLES_3_AGGREGATION: TEAM_AGGREGATION_TIE_FORMAT,
-  USTA_INTERSECTIONAL: USTA_INTERSECTIONAL$1,
-  USTA_LEVEL_1: USTA_LEVEL_1$1,
-  USTA_SOUTHERN_LEVEL_5: USTA_SOUTHERN_LEVEL_5$1,
-  USTA_ZONAL: USTA_ZONAL$1
+  USTA_INTERSECTIONAL: USTA_INTERSECTIONAL_TIE_FORMAT,
+  USTA_LEVEL_1: USTA_LEVEL_1_TIE_FORMAT,
+  USTA_SOUTHERN_LEVEL_5: USTA_SOUTHERN_LEVEL_5_TIE_FORMAT,
+  USTA_ZONAL: USTA_ZONAL_TIE_FORMAT
 };
 
 const POLICY_AVOIDANCE_COUNTRY = {
@@ -9909,26 +9909,29 @@ function getRoundMatchUps$1({
       roundProfile[roundNumber].drawPositions = orderedDrawPositions;
       roundProfile[roundNumber].pairedDrawPositions = pairedDrawPositions;
     } else {
-      const priorRoundDrawPositions = roundProfile[roundNumber - 1].drawPositions;
-      const chunkFactor = priorRoundDrawPositions.length / currentRoundDrawPositions.length;
+      const priorRound = roundProfile[roundNumber - 1];
+      const priorRoundDrawPositions = priorRound.drawPositions;
+      const chunkFactor = priorRound.matchUpsCount / roundProfile[roundNumber].matchUpsCount;
       const priorRoundDrawPositionChunks = chunkArray(priorRoundDrawPositions, chunkFactor); // ensures that drawPositions are returned in top to bottom order
 
       const roundDrawPositions = currentRoundMatchUps.map(matchUp => {
         const {
-          roundPosition,
-          drawPositions
+          roundPosition
         } = matchUp;
+        const drawPositions = [].concat(...(matchUp.drawPositions || []), undefined, undefined).slice(0, 2); // accounts for empty array, should always have length 2
+
         if (!roundPosition) return drawPositions;
         const filteredDrawPositions = (drawPositions === null || drawPositions === void 0 ? void 0 : drawPositions.filter(Boolean)) || [];
         if (!(filteredDrawPositions !== null && filteredDrawPositions !== void 0 && filteredDrawPositions.length)) return [undefined, undefined]; // { roundNumber: 2 } is the first possible feed round and the last time that a numeric sort is guaranteed to work
 
         if (roundNumber < 3 && (filteredDrawPositions === null || filteredDrawPositions === void 0 ? void 0 : filteredDrawPositions.length) === 2) {
           return drawPositions === null || drawPositions === void 0 ? void 0 : drawPositions.slice().sort(numericSort);
-        } // if the prior round does NOT include the one existing drawPosition then it is a feed round
-        // ... and fed positions are always { sideNumber: 1 }
+        }
 
+        const isFeedRound = intersection(priorRoundDrawPositions, filteredDrawPositions).length !== (filteredDrawPositions === null || filteredDrawPositions === void 0 ? void 0 : filteredDrawPositions.length); // if the prior round does NOT include the one existing drawPosition then it is a feed round
+        // ... and fed positions are always { sideNumber: 1 }
 
-        if (filteredDrawPositions !== null && filteredDrawPositions !== void 0 && filteredDrawPositions.length && intersection(priorRoundDrawPositions, filteredDrawPositions).length !== (filteredDrawPositions === null || filteredDrawPositions === void 0 ? void 0 : filteredDrawPositions.length)) {
+        if (filteredDrawPositions !== null && filteredDrawPositions !== void 0 && filteredDrawPositions.length && isFeedRound) {
           if ((filteredDrawPositions === null || filteredDrawPositions === void 0 ? void 0 : filteredDrawPositions.length) === 1) {
             return [filteredDrawPositions[0], undefined];
           } else {
@@ -9938,12 +9941,13 @@ function getRoundMatchUps$1({
         // this accounts for ADVANCED fed positions which are NOT guaranteed to be in numeric order
         // ... because a lower number fed position may be in { sideNumber: 2 } while an drawPosition advanced
         // from the first round may be in { sideNumber: 1 }
+        // const targetChunkIndex = (roundPosition - 1) * 2;
 
 
         const targetChunkIndex = (roundPosition - 1) * 2;
         const targetChunks = priorRoundDrawPositionChunks.slice(targetChunkIndex, targetChunkIndex + 2);
         const orderedPositions = targetChunks.map(chunk => {
-          const drawPositionInChunk = drawPositions === null || drawPositions === void 0 ? void 0 : drawPositions.find(drawPosition => chunk.includes(drawPosition));
+          const drawPositionInChunk = filteredDrawPositions === null || filteredDrawPositions === void 0 ? void 0 : filteredDrawPositions.find(drawPosition => chunk.includes(drawPosition));
           return drawPositionInChunk;
         });
         return orderedPositions;
@@ -11086,7 +11090,8 @@ function getOrderedDrawPositions({
   }
 
   const targetRoundProfile = roundProfile[roundNumber];
-  const displayOrder = (targetRoundProfile === null || targetRoundProfile === void 0 ? void 0 : targetRoundProfile.pairedDrawPositions.find(pair => overlap(pair || [], drawPositions.filter(Boolean)))) || unassignedDrawPositions; // ############# IMPORTANT DO NOT CHANGE #################
+  const pairedDrawPositions = targetRoundProfile === null || targetRoundProfile === void 0 ? void 0 : targetRoundProfile.pairedDrawPositions;
+  const displayOrder = (pairedDrawPositions === null || pairedDrawPositions === void 0 ? void 0 : pairedDrawPositions.find(pair => overlap(pair || [], drawPositions.filter(Boolean)))) || unassignedDrawPositions; // ############# IMPORTANT DO NOT CHANGE #################
   // when both present, drawPositions are always sorted numerically
   // this holds true even when fed positions encounter each other in later rounds
   // { sideNumber: 1 } always goes to the lower drawPosition
@@ -11098,8 +11103,16 @@ function getOrderedDrawPositions({
 
   if (allNumeric$1(drawPositions)) {
     const orderedDrawPositions = drawPositions.sort(numericSort);
-    return {
+    if (getDevContext({
+      sideNumbers: true
+    }) && drawPositions.length < 2) console.log({
+      drawPositions,
+      pairedDrawPositions,
       orderedDrawPositions,
+      displayOrder
+    });
+    return {
+      orderedDrawPositions: orderedDrawPositions.length === 2 ? orderedDrawPositions : displayOrder,
       displayOrder: isFeedRound ? orderedDrawPositions : displayOrder
     };
   } // ############# IMPORTANT DO NOT CHANGE #################
@@ -11696,6 +11709,7 @@ function getAllStructureMatchUps({
 
   let collectionPositionMatchUps = {},
       roundMatchUps = {};
+  tournamentParticipants = tournamentParticipants || (tournamentRecord === null || tournamentRecord === void 0 ? void 0 : tournamentRecord.participants);
 
   if (!structure) {
     return {
@@ -11752,7 +11766,6 @@ function getAllStructureMatchUps({
     seedAssignments: structureSeedAssignments
   } = getStructureSeedAssignments({
     drawDefinition,
-    matchUpsMap,
     structure
   }); // enables passing in seedAssignments rather than using structureSeedAssignments
 
@@ -11999,13 +12012,15 @@ function getAllStructureMatchUps({
         displayOrder
       } = getOrderedDrawPositions({
         drawPositions,
-        roundProfile,
         roundPosition,
+        roundProfile,
         roundNumber
       });
       const isFeedRound = roundProfile[roundNumber] && roundProfile[roundNumber].feedRound;
-      const reversedDisplayOrder = displayOrder[0] !== orderedDrawPositions[0];
-      const sides = orderedDrawPositions.map((drawPosition, index) => {
+      const reversedDisplayOrder = displayOrder[0] !== orderedDrawPositions[0]; // ensure there are two sides generated
+
+      const sideDrawPositions = orderedDrawPositions.concat(undefined, undefined).slice(0, 2);
+      const sides = sideDrawPositions.map((drawPosition, index) => {
         var _matchUp$sides;
 
         const sideNumber = index + 1;
@@ -12961,11 +12976,11 @@ function nextRoundMatchUp({
 }
 
 function getTargetMatchUp({
-  drawDefinition,
+  sourceRoundMatchUpCount,
   inContextDrawMatchUps,
-  targetLink,
   sourceRoundPosition,
-  sourceRoundMatchUpCount
+  drawDefinition,
+  targetLink
 }) {
   if (!targetLink) return {
     error: MISSING_TARGET_LINK
@@ -17023,7 +17038,11 @@ function removeDirectedParticipants(params) {
     winnerParticipantId: undefined,
     loserParticipantId: undefined
   });
-  const drawPositionMatchUps = sourceMatchUps.filter(matchUp => matchUp.drawPositions.includes(loserDrawPosition));
+  const drawPositionMatchUps = sourceMatchUps.filter(matchUp => {
+    var _matchUp$drawPosition;
+
+    return (_matchUp$drawPosition = matchUp.drawPositions) === null || _matchUp$drawPosition === void 0 ? void 0 : _matchUp$drawPosition.includes(loserDrawPosition);
+  });
 
   if (winnerMatchUp) {
     const result = removeDirectedWinner({
@@ -17674,7 +17693,6 @@ function advanceWinner({
         matchUpId: winnerMatchUp.matchUpId,
         inContextDrawMatchUps,
         drawDefinition,
-        iterative: 'brightmagenta',
         matchUpsMap
       });
     } else if (drawPositionIsBye) {
@@ -17767,7 +17785,7 @@ function getUpdatedDrawPositions({
 }) {
   let positionAdded;
   let positionAssigned = drawPositions === null || drawPositions === void 0 ? void 0 : drawPositions.includes(drawPosition);
-  const updatedDrawPositions = positionAssigned ? drawPositions : [].concat(...drawPositions, undefined, undefined).slice(0, 2) // accounts for empty array, should always have length 2
+  const updatedDrawPositions = positionAssigned ? drawPositions || [] : [].concat(...drawPositions, undefined, undefined).slice(0, 2) // accounts for empty array, should always have length 2
   .map(position => {
     if (!position && !positionAssigned) {
       positionAssigned = true;
@@ -17776,7 +17794,7 @@ function getUpdatedDrawPositions({
     } else {
       return position;
     }
-  }).sort(numericSort);
+  }).sort(numericSort).filter(Boolean);
   return {
     updatedDrawPositions,
     positionAdded,
@@ -17786,23 +17804,24 @@ function getUpdatedDrawPositions({
 
 function getWalkoverWinningSide({
   inContextDrawMatchUps,
-  matchUpId,
-  drawPosition
+  drawPosition,
+  matchUpId
 }) {
   // determine which sideNumber { drawPosition } will be and assign winningSide
   // NOTE: at present this is dependent on presence of .winnerMatchUpId and .loserMatchUpId
   // TODO: reusable function that will be able to use position targeting using links
   // which will need to filter by previous round then get positionTargets for each matchUp in the round
-  // sourceMatchUps MUST be sorted by roundPosition
   const sourceMatchUps = inContextDrawMatchUps.filter(({
     winnerMatchUpId,
     loserMatchUpId
-  }) => loserMatchUpId === matchUpId || winnerMatchUpId === matchUpId).sort((a, b) => a.roundPosition - b.roundPosition);
-  const feedRound = sourceMatchUps.find(({
-    feedRound
-  }) => feedRound);
+  }) => loserMatchUpId === matchUpId || winnerMatchUpId === matchUpId) // sourceMatchUps MUST be sorted by roundPosition
+  .sort((a, b) => a.roundPosition - b.roundPosition);
+  const matchUp = inContextDrawMatchUps.find(matchUp => matchUp.matchUpId === matchUpId);
+  const feedRound = matchUp.feedRound;
   return feedRound ? 1 : sourceMatchUps.reduce((sideNumber, sourceMatchUp, index) => {
-    if (sourceMatchUp.drawPositions.includes(drawPosition)) return index + 1;
+    var _sourceMatchUp$drawPo;
+
+    if ((_sourceMatchUp$drawPo = sourceMatchUp.drawPositions) !== null && _sourceMatchUp$drawPo !== void 0 && _sourceMatchUp$drawPo.includes(drawPosition)) return index + 1;
     return sideNumber;
   }, undefined);
 }
@@ -18113,9 +18132,12 @@ function conditionallyAdvanceDrawPosition(params) {
   if (result.error) return result; // when there is an existing WO/WO created WALKOVER it is replaced
   // with a DOUBLE_WALKOVER and move on to advancing from this position
 
-  if (existingWalkover) return doubleWalkoverAdvancement({ ...params,
-    targetData
-  });
+  if (existingWalkover) {
+    return doubleWalkoverAdvancement({ ...params,
+      targetData
+    });
+  }
+
   if (!nextWinnerMatchUp) return { ...SUCCESS
   }; // any remaining drawPosition in winnerMatchUp should be advanced
 
@@ -18141,23 +18163,28 @@ function conditionallyAdvanceDrawPosition(params) {
       });
 
       if (nextWinnerMatchUpHasDrawPosition) {
-        // if the next winnerMatchUp already has a drawPosition
+        const nextDrawPositionToAdvance = nextWinnerMatchUpDrawPositions.filter(Boolean)[0]; // if the next winnerMatchUp already has a drawPosition
+
+        const winningSide = getWalkoverWinningSide({
+          drawPosition: nextDrawPositionToAdvance,
+          matchUpId: noContextNextWinnerMatchUp.matchUpId,
+          inContextDrawMatchUps
+        });
         const result = modifyMatchUpScore({
           matchUpId: noContextNextWinnerMatchUp.matchUpId,
           matchUp: noContextNextWinnerMatchUp,
           matchUpStatus: WALKOVER$1,
           removeScore: true,
           drawDefinition,
-          winningSide: 1
+          winningSide
         });
         if (result.error) return result;
-        const drawPositionToAdvance = nextWinnerMatchUpDrawPositions.filter(Boolean)[0];
         return advanceDrawPosition({
-          drawPositionToAdvance,
+          drawPositionToAdvance: nextDrawPositionToAdvance,
+          matchUpId: noContextNextWinnerMatchUp.matchUpId,
           inContextDrawMatchUps,
           drawDefinition,
-          matchUpsMap,
-          matchUpId: noContextNextWinnerMatchUp.matchUpId
+          matchUpsMap
         });
       } else if (nextWinnerMatchUp.matchUpStatus === WALKOVER$1) {
         // if the next winnerMatchUp is a doubleWalkover
@@ -20039,15 +20066,23 @@ function removeDoubleWalkover(params) {
     }
 
     if (pairedPreviousMatchUpComplete) {
+      var _winnerMatchUp$drawPo;
+
       const sourceDrawPositions = matchUp.drawPositions || [];
-      let targetDrawPositions = winnerMatchUp.drawPositions.filter(Boolean);
+      let targetDrawPositions = (_winnerMatchUp$drawPo = winnerMatchUp.drawPositions) === null || _winnerMatchUp$drawPo === void 0 ? void 0 : _winnerMatchUp$drawPo.filter(Boolean);
 
       if (overlap(sourceDrawPositions, targetDrawPositions)) {
-        targetDrawPositions = targetDrawPositions.filter(drawPosition => !sourceDrawPositions.includes(drawPosition));
+        var _targetDrawPositions;
+
+        targetDrawPositions = (_targetDrawPositions = targetDrawPositions) === null || _targetDrawPositions === void 0 ? void 0 : _targetDrawPositions.filter(drawPosition => !sourceDrawPositions.includes(drawPosition));
       }
 
       const possibleBranchDrawPositions = sourceDrawPositions.concat(pairedPreviousDrawPositions);
-      const drawPositionToRemove = possibleBranchDrawPositions.find(drawPosition => targetDrawPositions.includes(drawPosition));
+      const drawPositionToRemove = possibleBranchDrawPositions.find(drawPosition => {
+        var _targetDrawPositions2;
+
+        return (_targetDrawPositions2 = targetDrawPositions) === null || _targetDrawPositions2 === void 0 ? void 0 : _targetDrawPositions2.includes(drawPosition);
+      });
 
       if (nextWinnerMatchUp && drawPositionToRemove) {
         const result = removeDirectedWinner({
@@ -20223,20 +20258,21 @@ function isActiveDownstream(params) {
   });
   let winnerTargetData = winnerMatchUp && positionTargets({
     matchUpId: winnerMatchUp.matchUpId,
-    drawDefinition,
-    inContextDrawMatchUps
+    inContextDrawMatchUps,
+    drawDefinition
   });
   const loserActive = loserTargetData && isActiveDownstream({
     inContextDrawMatchUps,
-    drawDefinition,
-    targetData: loserTargetData
+    targetData: loserTargetData,
+    drawDefinition
   });
   const winnerActive = winnerTargetData && isActiveDownstream({
     inContextDrawMatchUps,
-    drawDefinition,
-    targetData: winnerTargetData
+    targetData: winnerTargetData,
+    drawDefinition
   });
-  return !!(winnerActive || loserActive);
+  const isActive = !!(winnerActive || loserActive);
+  return isActive;
 }
 
 /**
@@ -20498,7 +20534,7 @@ function setMatchUpStatus$2(params) {
       matchUpsMap,
       event
     });
-    const tieFormat = (dualMatchUp === null || dualMatchUp === void 0 ? void 0 : dualMatchUp.tieFormat) || (drawDefinition === null || drawDefinition === void 0 ? void 0 : drawDefinition.tieFormat) || (event === null || event === void 0 ? void 0 : event.tieFormat) || undefined;
+    const tieFormat = (dualMatchUp === null || dualMatchUp === void 0 ? void 0 : dualMatchUp.tieFormat) || (structure === null || structure === void 0 ? void 0 : structure.tieFormat) || (drawDefinition === null || drawDefinition === void 0 ? void 0 : drawDefinition.tieFormat) || (event === null || event === void 0 ? void 0 : event.tieFormat) || undefined;
     const {
       projectedWinningSide
     } = getProjectedDualWinningSide({
@@ -22676,10 +22712,132 @@ const scaleConstants = {
   SEEDING
 };
 
+function getAccessorValue({
+  element,
+  accessor
+}) {
+  if (typeof accessor !== 'string') return {
+    values: []
+  };
+  const targetElement = makeDeepCopy(element);
+  const attributes = accessor.split('.');
+  let value,
+      values = [];
+  processKeys({
+    targetElement,
+    attributes
+  });
+  const result = {
+    value
+  };
+  if (values.length) result.values = values;
+  return result;
+
+  function processKeys({
+    targetElement,
+    attributes = [],
+    significantCharacters
+  }) {
+    for (const [index, attribute] of attributes.entries()) {
+      if (targetElement && targetElement[attribute]) {
+        if (Array.isArray(targetElement[attribute])) {
+          const values = targetElement[attribute];
+          const remainingKeys = attributes.slice(index);
+          values.forEach(nestedTarget => processKeys({
+            targetElement: nestedTarget,
+            attributes: remainingKeys
+          }));
+        } else {
+          targetElement = targetElement[attribute];
+          checkValue({
+            targetElement,
+            index
+          });
+        }
+      }
+    }
+
+    function checkValue({
+      targetElement,
+      index
+    }) {
+      if (targetElement && index === attributes.length - 1 && ['string', 'number'].includes(typeof targetElement)) {
+        const extractedValue = significantCharacters ? targetElement.slice(0, significantCharacters) : targetElement;
+
+        if (value) {
+          if (!values.includes(extractedValue)) {
+            values.push(extractedValue);
+          }
+        } else {
+          value = extractedValue;
+          values.push(extractedValue);
+        }
+      }
+    }
+  }
+}
+
+function participantScaleItem({
+  requireTimeStamp,
+  scaleAttributes,
+  participant
+}) {
+  if (!participant) return {
+    error: MISSING_PARTICIPANT
+  };
+  if (typeof scaleAttributes !== 'object') return {
+    error: INVALID_VALUES
+  };
+  if (!participant.timeItems) participant.timeItems = [];
+
+  if (participant && Array.isArray(participant.timeItems)) {
+    const {
+      accessor,
+      scaleType,
+      eventType,
+      scaleName
+    } = scaleAttributes;
+    const filterType = [SCALE, scaleType, eventType, scaleName].join('.');
+    const filteredTimeItems = participant.timeItems.filter(timeItem => (timeItem === null || timeItem === void 0 ? void 0 : timeItem.itemType) === filterType).filter(timeItem => !requireTimeStamp || (timeItem === null || timeItem === void 0 ? void 0 : timeItem.itemDate)).sort((a, b) => new Date(a.createdAt || undefined) - new Date(b.createdAt || undefined));
+    const timeItem = filteredTimeItems.pop();
+
+    if (timeItem) {
+      const [itemSubject, scaleType, eventType, scaleName] = timeItem.itemType.split('.');
+      if (itemSubject !== SCALE) return {
+        error: INVALID_SCALE_ITEM
+      };
+      const accessorValue = accessor && getAccessorValue({
+        element: timeItem.itemValue,
+        accessor
+      });
+      const scaleValue = accessor ? accessorValue.value : timeItem.itemValue;
+      const scaleItem = {
+        scaleDate: timeItem.itemDate,
+        scaleName,
+        scaleType,
+        eventType,
+        scaleValue
+      };
+      return {
+        scaleItem
+      };
+    } else {
+      return {
+        error: SCALE_ITEM_NOT_FOUND
+      };
+    }
+  }
+
+  return {
+    error: MISSING_PARTICIPANT
+  };
+}
+
 function addParticipantContext(params) {
   var _params$tournamentPar;
 
   const participantIdsWithConflicts = [];
+  const eventsPublishStatuses = {};
   const drawSizes = {};
   const participantIdMap = {};
 
@@ -22774,7 +22932,7 @@ function addParticipantContext(params) {
 
     // loop through all filtered events and capture events played
     (_params$tournamentEve = params.tournamentEvents) === null || _params$tournamentEve === void 0 ? void 0 : _params$tournamentEve.forEach(rawEvent => {
-      var _event$drawDefinition, _eventInfo$_flightPro, _eventInfo$_flightPro2;
+      var _timeItem$itemValue, _event$drawDefinition, _eventInfo$_flightPro, _eventInfo$_flightPro2;
 
       const event = makeDeepCopy(rawEvent, true, true);
       const {
@@ -22791,7 +22949,37 @@ function addParticipantContext(params) {
       };
       const extensionKeys = event && Object.keys(event).filter(key => key[0] === '_');
       extensionKeys === null || extensionKeys === void 0 ? void 0 : extensionKeys.forEach(extensionKey => eventInfo[extensionKey] = event[extensionKey]);
-      const eventEntries = event.entries || []; // don't allow system extensions to be copied to participants
+      const eventEntries = event.entries || [];
+      const itemType = `${PUBLISH}.${STATUS$1}`;
+      const {
+        timeItem
+      } = getEventTimeItem({
+        itemType,
+        event
+      });
+
+      if (timeItem !== null && timeItem !== void 0 && (_timeItem$itemValue = timeItem.itemValue) !== null && _timeItem$itemValue !== void 0 && _timeItem$itemValue.PUBLIC) {
+        var _timeItem$itemValue2;
+
+        const {
+          drawIds: publishedDrawIds = [],
+          seeding
+        } = (timeItem === null || timeItem === void 0 ? void 0 : (_timeItem$itemValue2 = timeItem.itemValue) === null || _timeItem$itemValue2 === void 0 ? void 0 : _timeItem$itemValue2.PUBLIC) || {};
+        const publishedSeeding = {
+          event: undefined,
+          // seeding can be present for all entries in an event when no flights have been defined
+          drawIds: [],
+          // seeding can be specific to drawIds
+          stages: [] // seeding can be specific to { stageSequence: 1 } for each stage
+
+        };
+        if (seeding) Object.assign(publishedSeeding, timeItem.itemValue.PUBLIC.seeding);
+        eventsPublishStatuses[eventId] = {
+          publishedDrawIds,
+          publishedSeeding
+        };
+      } // don't allow system extensions to be copied to participants
+
 
       const disallowedConstants = [].concat(...Object.values(extensionConstants));
       const disallowedKeys = disallowedConstants.map(constant => `_${constant}`);
@@ -23230,7 +23418,8 @@ function addParticipantContext(params) {
   }
 
   return {
-    participantIdsWithConflicts
+    participantIdsWithConflicts,
+    eventsPublishStatuses
   };
 }
 
@@ -23304,8 +23493,75 @@ function annotateParticipant({
   };
   const participantDraws = Object.values(draws);
   const participantEvents = Object.values(events);
-  withDraws && participantDraws && (participant.draws = participantDraws);
-  withEvents && participantEvents && (participant.events = participantEvents);
+
+  if (withDraws && participantDraws) {
+    participant.draws = participantDraws;
+
+    for (const participantDraw of participantDraws) {
+      var _result;
+
+      const event = participantEvents === null || participantEvents === void 0 ? void 0 : participantEvents.find(e => e.eventId === participantDraw.eventId);
+      const {
+        categoryName,
+        ageCategoryCode
+      } = (event === null || event === void 0 ? void 0 : event.category) || {};
+      let result = participantScaleItem({
+        scaleAttributes: {
+          scaleType: SEEDING,
+          scaleName: participantDraw.drawId,
+          eventType: event === null || event === void 0 ? void 0 : event.eventType
+        },
+        participant
+      });
+
+      if ((_result = result) !== null && _result !== void 0 && _result.scaleItem) {
+        participantDraw.seedValue = result.scaleItem.scaleValue;
+      } else {
+        var _result2;
+
+        result = participantScaleItem({
+          scaleAttributes: {
+            scaleType: SEEDING,
+            scaleName: categoryName || ageCategoryCode,
+            eventType: event === null || event === void 0 ? void 0 : event.eventType
+          },
+          participant
+        });
+
+        if ((_result2 = result) !== null && _result2 !== void 0 && _result2.scaleItem) {
+          participantDraw.seedValue = result.scaleItem.scaleValue;
+        }
+      }
+    }
+  }
+
+  if (withEvents && participantEvents) {
+    participant.events = participantEvents;
+
+    for (const participantEvent of participantEvents) {
+      const {
+        categoryName,
+        ageCategoryCode
+      } = participantEvent.category || {};
+      const scaleAttributes = {
+        scaleType: SEEDING,
+        scaleName: categoryName || ageCategoryCode,
+        eventType: participantEvent.eventType
+      };
+      const result = participantScaleItem({
+        scaleAttributes,
+        participant
+      });
+      const {
+        scaleItem
+      } = result;
+
+      if (scaleItem) {
+        participantEvent.seedValue = scaleItem.scaleValue;
+      }
+    }
+  }
+
   const participantOpponents = Object.values(opponents).flat();
 
   if (withOpponents && participantOpponents !== null && participantOpponents !== void 0 && participantOpponents.length) {
@@ -23412,71 +23668,6 @@ function annotateParticipant({
   };
 }
 
-function getAccessorValue({
-  element,
-  accessor
-}) {
-  if (typeof accessor !== 'string') return {
-    values: []
-  };
-  const targetElement = makeDeepCopy(element);
-  const attributes = accessor.split('.');
-  let value,
-      values = [];
-  processKeys({
-    targetElement,
-    attributes
-  });
-  const result = {
-    value
-  };
-  if (values.length) result.values = values;
-  return result;
-
-  function processKeys({
-    targetElement,
-    attributes = [],
-    significantCharacters
-  }) {
-    for (const [index, attribute] of attributes.entries()) {
-      if (targetElement && targetElement[attribute]) {
-        if (Array.isArray(targetElement[attribute])) {
-          const values = targetElement[attribute];
-          const remainingKeys = attributes.slice(index);
-          values.forEach(nestedTarget => processKeys({
-            targetElement: nestedTarget,
-            attributes: remainingKeys
-          }));
-        } else {
-          targetElement = targetElement[attribute];
-          checkValue({
-            targetElement,
-            index
-          });
-        }
-      }
-    }
-
-    function checkValue({
-      targetElement,
-      index
-    }) {
-      if (targetElement && index === attributes.length - 1 && ['string', 'number'].includes(typeof targetElement)) {
-        const extractedValue = significantCharacters ? targetElement.slice(0, significantCharacters) : targetElement;
-
-        if (value) {
-          if (!values.includes(extractedValue)) {
-            values.push(extractedValue);
-          }
-        } else {
-          value = extractedValue;
-          values.push(extractedValue);
-        }
-      }
-    }
-  }
-}
-
 function filterParticipants({
   tournamentRecord,
   participantFilters,
@@ -23678,7 +23869,7 @@ function getTournamentParticipants({
     participants: tournamentParticipants
   });
   const addContext = withSignInStatus || withScheduleItems || scheduleAnalysis || withStatistics || withGroupings || withOpponents || withMatchUps || withEvents || withDraws || withISO;
-  let participantIdsWithConflicts;
+  let participantIdsWithConflicts, eventsPublishStatuses;
 
   if (addContext) {
     const result = addParticipantContext({
@@ -23698,6 +23889,7 @@ function getTournamentParticipants({
       withISO
     });
     participantIdsWithConflicts = result === null || result === void 0 ? void 0 : result.participantIdsWithConflicts;
+    eventsPublishStatuses = result === null || result === void 0 ? void 0 : result.eventsPublishStatuses;
   }
 
   const participantAttributes = policyDefinitions === null || policyDefinitions === void 0 ? void 0 : policyDefinitions[POLICY_TYPE_PARTICIPANT];
@@ -23710,8 +23902,9 @@ function getTournamentParticipants({
   }
 
   return {
+    participantIdsWithConflicts,
     tournamentParticipants,
-    participantIdsWithConflicts
+    eventsPublishStatuses
   };
 }
 
@@ -30071,10 +30264,7 @@ function buildRound({
       roundNumber,
       roundPosition,
       matchUpStatus: TO_BE_PLAYED,
-      // TODO: undefined drawPositions can be filtered; several tests will have to be updated
-      // UNDEFINED drawPositions
-      // drawPositions: node.children.map((c) => c.drawPosition).filter(Boolean),
-      drawPositions: node.children.map(c => c.drawPosition)
+      drawPositions: node.children.map(c => c.drawPosition).filter(Boolean)
     }; // matchUpType is derived for inContext matchUps from structure or drawDefinition
 
     if (includeMatchUpType) matchUp.matchUpType = matchUpType;
@@ -31773,7 +31963,7 @@ function generatePositioningCandidate(params) {
   } = params;
   const errors = [];
   let groupKey;
-  const groupSize = Math.min(...drawPositionGroups.map(dpg => dpg.length));
+  const groupSize = Math.min(...(drawPositionGroups === null || drawPositionGroups === void 0 ? void 0 : drawPositionGroups.map(dpg => dpg === null || dpg === void 0 ? void 0 : dpg.length).filter(Boolean)));
   const isRoundRobin = groupSize > 2;
   const candidatePositionAssignments = makeDeepCopy(initialPositionAssignments, false, true); // all drawPositions which are available for placement
 
@@ -36298,11 +36488,10 @@ function removeParticipantIdsFromAllTeams({
 }
 
 function deleteParticipants({
-  teamDrawIds = [],
   tournamentRecord,
   participantIds
 }) {
-  var _tournamentRecord$par;
+  var _tournamentRecord$par, _tournamentRecord$eve;
 
   if (!tournamentRecord) return {
     error: MISSING_TOURNAMENT_RECORD
@@ -36312,6 +36501,15 @@ function deleteParticipants({
   };
   const participantsCount = ((_tournamentRecord$par = tournamentRecord.participants) === null || _tournamentRecord$par === void 0 ? void 0 : _tournamentRecord$par.length) || 0;
   if (!participantsCount) return SUCCESS;
+  const teamDrawIds = (_tournamentRecord$eve = tournamentRecord.events) === null || _tournamentRecord$eve === void 0 ? void 0 : _tournamentRecord$eve.filter(({
+    eventType
+  }) => eventType === TEAM$2).map(event => {
+    var _event$drawDefinition;
+
+    return event === null || event === void 0 ? void 0 : (_event$drawDefinition = event.drawDefinitions) === null || _event$drawDefinition === void 0 ? void 0 : _event$drawDefinition.map(({
+      drawId
+    }) => drawId);
+  }).flat(Infinity);
   const {
     tournamentParticipants
   } = getTournamentParticipants({
@@ -36322,34 +36520,34 @@ function deleteParticipants({
     tournamentRecord
   });
 
-  const getPlacedParticipantIds = () => {
+  const getPlacedPairParticipantIds = () => {
     const {
       matchUps
     } = allTournamentMatchUps({
-      tournamentRecord,
       matchUpFilters: {
         drawIds: teamDrawIds,
         matchUpTypes: [DOUBLES$1]
-      }
+      },
+      tournamentRecord
     });
-    const placedParticipantIds = matchUps.map(({
+    const placedPairParticipantIds = matchUps.map(({
       sides
     }) => sides.map(({
       participantId
     }) => participantId)).flat().filter(Boolean);
-    return intersection(placedParticipantIds, participantIds);
+    return intersection(placedPairParticipantIds, participantIds);
   }; // for team draws it is necessary to check matchUps for pair participantIds "discovered" in collectionAssignments
 
 
-  const placedParticipantIds = teamDrawIds.length && getPlacedParticipantIds();
+  const placedPairParticipantIds = (teamDrawIds === null || teamDrawIds === void 0 ? void 0 : teamDrawIds.length) && getPlacedPairParticipantIds();
   const participantsInDraws = tournamentParticipants.filter(participant => {
     var _participant$draws;
 
     return (_participant$draws = participant.draws) === null || _participant$draws === void 0 ? void 0 : _participant$draws.filter(({
       drawId
-    }) => !teamDrawIds.length || !teamDrawIds.includes(drawId)).length;
+    }) => !(teamDrawIds !== null && teamDrawIds !== void 0 && teamDrawIds.length) || !(teamDrawIds !== null && teamDrawIds !== void 0 && teamDrawIds.includes(drawId))).length;
   });
-  if (placedParticipantIds.length || participantsInDraws.length) return {
+  if (placedPairParticipantIds !== null && placedPairParticipantIds !== void 0 && placedPairParticipantIds.length || participantsInDraws.length) return {
     error: PARTICIPANT_ASSIGNED_DRAW_POSITION
   }; // If not active in draws, remove participantIds from all entries
 
@@ -37506,62 +37704,6 @@ function removeDelegatedOutcome$1({
   });
 }
 
-function participantScaleItem({
-  requireTimeStamp,
-  scaleAttributes,
-  participant
-}) {
-  if (!participant) return {
-    error: MISSING_PARTICIPANT
-  };
-  if (typeof scaleAttributes !== 'object') return {
-    error: INVALID_VALUES
-  };
-  if (!participant.timeItems) participant.timeItems = [];
-
-  if (participant && Array.isArray(participant.timeItems)) {
-    const {
-      accessor,
-      scaleType,
-      eventType,
-      scaleName
-    } = scaleAttributes;
-    const filterType = [SCALE, scaleType, eventType, scaleName].join('.');
-    const filteredTimeItems = participant.timeItems.filter(timeItem => (timeItem === null || timeItem === void 0 ? void 0 : timeItem.itemType) === filterType).filter(timeItem => !requireTimeStamp || (timeItem === null || timeItem === void 0 ? void 0 : timeItem.itemDate)).sort((a, b) => new Date(a.createdAt || undefined) - new Date(b.createdAt || undefined));
-    const timeItem = filteredTimeItems.pop();
-
-    if (timeItem) {
-      const [itemSubject, scaleType, eventType, scaleName] = timeItem.itemType.split('.');
-      if (itemSubject !== SCALE) return {
-        error: INVALID_SCALE_ITEM
-      };
-      const accessorValue = accessor && getAccessorValue({
-        element: timeItem.itemValue,
-        accessor
-      });
-      const scaleValue = accessor ? accessorValue.value : timeItem.itemValue;
-      const scaleItem = {
-        scaleDate: timeItem.itemDate,
-        scaleName,
-        scaleType,
-        eventType,
-        scaleValue
-      };
-      return {
-        scaleItem
-      };
-    } else {
-      return {
-        error: SCALE_ITEM_NOT_FOUND
-      };
-    }
-  }
-
-  return {
-    error: MISSING_PARTICIPANT
-  };
-}
-
 function generateCandidate({
   maxIterations = 5000,
   // cap the processing intensity of the candidate generator
@@ -43818,7 +43960,11 @@ const namedFormats = {
   },
   [LAVER_CUP]: LAVER_CUP_TIE_FORMAT,
   [DOMINANT_DUO]: DOMINANT_DUO_TIE_FORMAT,
-  [TEAM_DOUBLES_3_AGGREGATION]: TEAM_AGGREGATION_TIE_FORMAT
+  [TEAM_DOUBLES_3_AGGREGATION]: TEAM_AGGREGATION_TIE_FORMAT,
+  [USTA_INTERSECTIONAL]: USTA_INTERSECTIONAL_TIE_FORMAT,
+  [USTA_LEVEL_1]: USTA_LEVEL_1_TIE_FORMAT,
+  [USTA_SOUTHERN_LEVEL_5]: USTA_SOUTHERN_LEVEL_5_TIE_FORMAT,
+  [USTA_ZONAL]: USTA_ZONAL_TIE_FORMAT
 };
 const tieFormatDefaults = ({
   namedFormat,
@@ -44436,7 +44582,6 @@ function assignTieMatchUpParticipantId(params) {
   if (deleteParticipantId) {
     const result = deleteParticipants({
       participantIds: [deleteParticipantId],
-      teamDrawIds: [drawDefinition.drawId],
       tournamentRecord
     });
     if (result.error) console.log('cleanup', {
@@ -51649,25 +51794,132 @@ function completeDrawMatchUps({
   matchUpStatusProfile,
   completeAllMatchUps,
   randomWinningSide,
+  tournamentRecord,
   drawDefinition,
   completionGoal,
   matchUpFormat,
   event
 }) {
   const sortedStructures = drawDefinition.structures.slice().sort(structureSort);
-  let completedCount = 0; // to support legacy tests it is possible to use completeAllMatchUps
+  let completedCount = 0;
+  let {
+    matchUps: firstRoundDualMatchUps,
+    matchUpsMap
+  } = getAllDrawMatchUps({
+    contextFilters: {
+      stages: [MAIN]
+    },
+    matchUpFilters: {
+      matchUpTypes: [TEAM$3],
+      roundNumbers: [1]
+    },
+    inContext: true,
+    drawDefinition
+  });
+
+  if (firstRoundDualMatchUps.length) {
+    var _firstRoundDualMatchU;
+
+    const structureId = (_firstRoundDualMatchU = firstRoundDualMatchUps[0]) === null || _firstRoundDualMatchU === void 0 ? void 0 : _firstRoundDualMatchU.structureId;
+    const {
+      positionAssignments
+    } = getPositionAssignments$1({
+      drawDefinition,
+      structureId
+    });
+
+    if (positionAssignments !== null && positionAssignments !== void 0 && positionAssignments.length) {
+      let {
+        tournamentParticipants: teamParticipants
+      } = getTournamentParticipants({
+        participantFilters: {
+          participantTypes: [TEAM$3]
+        },
+        tournamentRecord
+      });
+
+      const assignParticipants = dualMatchUp => {
+        const singlesMatchUps = dualMatchUp.tieMatchUps.filter(({
+          matchUpType
+        }) => matchUpType === SINGLES$1);
+        const doublesMatchUps = dualMatchUp.tieMatchUps.filter(({
+          matchUpType
+        }) => matchUpType === DOUBLES$1);
+        singlesMatchUps.forEach((singlesMatchUp, i) => {
+          const tieMatchUpId = singlesMatchUp.matchUpId;
+          singlesMatchUp.sides.forEach(side => {
+            const {
+              drawPosition
+            } = side;
+            const teamParticipant = teamParticipants.find(teamParticipant => {
+              const {
+                participantId
+              } = teamParticipant;
+              const assignment = positionAssignments.find(assignment => assignment.participantId === participantId);
+              return assignment.drawPosition === drawPosition;
+            });
+
+            if (teamParticipant) {
+              const individualParticipantId = teamParticipant.individualParticipantIds[i];
+              const result = assignTieMatchUpParticipantId({
+                participantId: individualParticipantId,
+                tournamentRecord,
+                drawDefinition,
+                tieMatchUpId,
+                event
+              });
+              if (!result.success) console.log(result);
+            }
+          });
+        });
+        doublesMatchUps.forEach((doublesMatchUp, i) => {
+          const tieMatchUpId = doublesMatchUp.matchUpId;
+          doublesMatchUp.sides.forEach(side => {
+            const {
+              drawPosition
+            } = side;
+            const teamParticipant = teamParticipants.find(teamParticipant => {
+              const {
+                participantId
+              } = teamParticipant;
+              const assignment = positionAssignments.find(assignment => assignment.participantId === participantId);
+              return assignment.drawPosition === drawPosition;
+            });
+
+            if (teamParticipant) {
+              const individualParticipantIds = teamParticipant.individualParticipantIds.slice(i * 2, i * 2 + 2);
+              individualParticipantIds.forEach(individualParticipantId => {
+                const result = assignTieMatchUpParticipantId({
+                  participantId: individualParticipantId,
+                  tournamentRecord,
+                  drawDefinition,
+                  tieMatchUpId,
+                  event
+                });
+                if (!result.success) console.log(result);
+              });
+            }
+          });
+        });
+      };
+
+      firstRoundDualMatchUps.forEach(assignParticipants);
+    }
+  } // to support legacy tests it is possible to use completeAllMatchUps
   // to pass a score string that will be applied to all matchUps
 
+
   const scoreString = typeof completeAllMatchUps === 'string' && completeAllMatchUps;
   const matchUpStatus = scoreString && COMPLETED;
 
   for (const structure of sortedStructures) {
-    const matchUpsMap = getMatchUpsMap({
-      drawDefinition
-    });
     const {
       matchUps
     } = getAllStructureMatchUps({
+      matchUpFilters: {
+        matchUpTypes: [DOUBLES$1, SINGLES$1]
+      },
+      tournamentRecord,
       inContext: true,
       drawDefinition,
       matchUpsMap,
@@ -51683,6 +51935,10 @@ function completeDrawMatchUps({
       const {
         matchUps
       } = getAllStructureMatchUps({
+        matchUpFilters: {
+          matchUpTypes: [DOUBLES$1, SINGLES$1]
+        },
+        tournamentRecord,
         inContext: true,
         drawDefinition,
         matchUpsMap,
@@ -51912,12 +52168,14 @@ function generateFlightDrawDefinitions({
         if (!manual && (completeAllMatchUps || completionGoal)) {
           const matchUpFormat = drawProfile === null || drawProfile === void 0 ? void 0 : drawProfile.matchUpFormat;
           const result = completeDrawMatchUps({
-            matchUpStatusProfile,
             completeAllMatchUps: !completionGoal && completeAllMatchUps,
+            matchUpStatusProfile,
             randomWinningSide,
+            tournamentRecord,
             completionGoal,
             drawDefinition,
-            matchUpFormat
+            matchUpFormat,
+            event
           });
           if (result.error) return result;
           const completedCount = result.completedCount;
@@ -51937,8 +52195,10 @@ function generateFlightDrawDefinitions({
               completionGoal: completionGoal ? playoffCompletionGoal : undefined,
               matchUpStatusProfile,
               randomWinningSide,
+              tournamentRecord,
               drawDefinition,
-              matchUpFormat
+              matchUpFormat,
+              event
             });
             if (result.error) return result;
           }
@@ -52989,6 +53249,7 @@ function generateEventWithDraw({
         const individualParticipantIds = allIndividualParticipantIds.slice(teamIndex * teamSize, (teamIndex + 1) * teamSize);
         return {
           participantName: `Team ${teamIndex + 1}`,
+          participantOtherName: `TM${teamIndex + 1}`,
           participantRole: COMPETITOR,
           participantType: TEAM$1,
           participantId: UUID(),
@@ -53143,6 +53404,45 @@ function generateEventWithDraw({
     const manual = drawProfile.automated === false;
 
     if (!manual) {
+      if (completeAllMatchUps || completionGoal) {
+        const result = completeDrawMatchUps({
+          matchUpStatusProfile,
+          completeAllMatchUps,
+          randomWinningSide,
+          tournamentRecord,
+          completionGoal,
+          drawDefinition,
+          matchUpFormat,
+          event
+        });
+        if (result.error) return result;
+        const completedCount = result.completedCount;
+
+        if (drawType === ROUND_ROBIN_WITH_PLAYOFF) {
+          const mainStructure = drawDefinition.structures.find(structure => structure.stage === MAIN);
+          let result = automatedPlayoffPositioning({
+            structureId: mainStructure.structureId,
+            tournamentRecord,
+            drawDefinition,
+            event
+          }); // ignore when positioning cannot occur because of incomplete source structure
+
+          const playoffCompletionGoal = completionGoal ? completionGoal - completedCount : undefined;
+          result = completeDrawMatchUps({
+            completionGoal: completionGoal ? playoffCompletionGoal : undefined,
+            matchUpStatusProfile,
+            completeAllMatchUps,
+            randomWinningSide,
+            tournamentRecord,
+            drawDefinition,
+            matchUpFormat,
+            event
+          });
+          if (result.error) return result;
+        } // TODO: check if RRWPO & automate & complete
+
+      }
+
       if (drawProfile.outcomes) {
         const {
           matchUps
@@ -53204,41 +53504,6 @@ function generateEventWithDraw({
           if (result !== null && result !== void 0 && result.error) return result;
         }
       }
-
-      if (completeAllMatchUps || completionGoal) {
-        const result = completeDrawMatchUps({
-          matchUpStatusProfile,
-          completeAllMatchUps,
-          randomWinningSide,
-          completionGoal,
-          drawDefinition,
-          matchUpFormat
-        });
-        if (result.error) return result;
-        const completedCount = result.completedCount;
-
-        if (drawType === ROUND_ROBIN_WITH_PLAYOFF) {
-          const mainStructure = drawDefinition.structures.find(structure => structure.stage === MAIN);
-          let result = automatedPlayoffPositioning({
-            structureId: mainStructure.structureId,
-            tournamentRecord,
-            drawDefinition,
-            event
-          }); // ignore when positioning cannot occur because of incomplete source structure
-
-          const playoffCompletionGoal = completionGoal ? completionGoal - completedCount : undefined;
-          result = completeDrawMatchUps({
-            completionGoal: completionGoal ? playoffCompletionGoal : undefined,
-            matchUpStatusProfile,
-            completeAllMatchUps,
-            randomWinningSide,
-            drawDefinition,
-            matchUpFormat
-          });
-          if (result.error) return result;
-        } // TODO: check if RRWPO & automate & complete
-
-      }
     }
 
     if (publish) {