tods-competition-factory 1.6.28 → 1.6.30

package/dist/index.mjs

@@ -329,7 +329,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.6.28";
+  return "1.6.30";
 }
 
 function getObjectTieFormat(obj) {
@@ -1425,7 +1425,8 @@ var syncGlobalState$1 = {
   setSubscriptions: setSubscriptions$1,
   setTournamentId: setTournamentId$1,
   setTournamentRecord: setTournamentRecord$2,
-  setTournamentRecords: setTournamentRecords$1
+  setTournamentRecords: setTournamentRecords$1,
+  handleCaughtError: handleCaughtError$1
 };
 function disableNotifications$1() {
   syncGlobalState.disableNotifications = true;
@@ -1531,6 +1532,26 @@ function callListener$1({ topic, notices }) {
     method(notices);
   }
 }
+function handleCaughtError$1({
+  engineName,
+  methodName,
+  params,
+  err
+}) {
+  let error;
+  if (typeof err === "string") {
+    error = err.toUpperCase();
+  } else if (err instanceof Error) {
+    error = err.message;
+  }
+  console.log("ERROR", {
+    tournamentId: getTournamentId$1(),
+    params: JSON.stringify(params),
+    engine: engineName,
+    methodName,
+    error
+  });
+}
 
 const globalState = {
   tournamentFactoryVersion: "0.0.0",
@@ -1550,6 +1571,8 @@ const requiredStateProviderMethods = [
   "cycleMutationStatus",
   "deleteNotice",
   "deleteNotices",
+  "disableNotifications",
+  "enableNotifications",
   "getNotices",
   "getTopics",
   "getTournamentId",
@@ -1649,8 +1672,8 @@ function cycleMutationStatus() {
 function addNotice(notice) {
   return _globalStateProvider.addNotice(notice);
 }
-function getNotices(topic) {
-  return _globalStateProvider.getNotices(topic);
+function getNotices(params) {
+  return _globalStateProvider.getNotices(params);
 }
 function deleteNotice({ key, topic }) {
   return _globalStateProvider.deleteNotice({ key, topic });
@@ -1685,6 +1708,20 @@ function setTournamentId(tournamentId) {
 function removeTournamentRecord(tournamentId) {
   return _globalStateProvider.removeTournamentRecord(tournamentId);
 }
+function handleCaughtError({
+  engineName,
+  methodName,
+  params,
+  err
+}) {
+  const caughtErrorHandler = typeof _globalStateProvider.handleCaughtError === "function" && _globalStateProvider.handleCaughtError || syncGlobalState$1.handleCaughtError;
+  return caughtErrorHandler({
+    engineName,
+    methodName,
+    params,
+    err
+  });
+}
 
 function isObject(obj) {
   return typeof obj === "object";
@@ -38377,18 +38414,11 @@ const competitionEngine = function() {
             try {
               return engineInvoke(governor[methodName], params, methodName);
             } catch (err) {
-              const activeTournamentId = getTournamentId();
-              let error;
-              if (typeof err === "string") {
-                error = err.toUpperCase();
-              } else if (err instanceof Error) {
-                error = err.message;
-              }
-              console.log("ERROR", {
-                params: JSON.stringify(params),
-                activeTournamentId,
+              handleCaughtError({
+                engineName: "competitionEngine",
                 methodName,
-                error
+                params,
+                err
               });
             }
           }
@@ -38545,26 +38575,19 @@ function competitionEngineAsync(test) {
   async function importGovernors(governors) {
     for (const governor of governors) {
       const govKeys = Object.keys(governor);
-      for (const method of govKeys) {
-        engine[method] = async function(params) {
+      for (const methodName of govKeys) {
+        engine[methodName] = async function(params) {
           if (getDevContext()) {
-            return await engineInvoke(governor[method], params);
+            return await engineInvoke(governor[methodName], params);
           } else {
             try {
-              return await engineInvoke(governor[method], params);
+              return await engineInvoke(governor[methodName], params);
             } catch (err) {
-              const activeTournamentId = getTournamentId();
-              let error;
-              if (typeof err === "string") {
-                error = err.toUpperCase();
-              } else if (err instanceof Error) {
-                error = err.message;
-              }
-              console.log("ERROR", {
-                params: JSON.stringify(params),
-                activeTournamentId,
-                method,
-                error
+              handleCaughtError({
+                engineName: "competitionEngine",
+                methodName,
+                params,
+                err
               });
             }
           }
@@ -40001,9 +40024,9 @@ function processPlayoffGroups({
   for (const playoffGroup of playoffGroups) {
     const finishingPositions = playoffGroup.finishingPositions;
     const positionsPlayedOff = positionRangeMap && finishingPositions.map((p) => positionRangeMap[p]?.finishingPositions).flat();
-    const playoffDrawType = playoffGroup.drawType || SINGLE_ELIMINATION;
     const participantsInDraw = groupCount * finishingPositions.length;
     const drawSize = nextPowerOf2(participantsInDraw);
+    const playoffDrawType = drawSize === 2 && SINGLE_ELIMINATION || playoffGroup.drawType || SINGLE_ELIMINATION;
     if (positionsPlayedOff) {
       finishingPositionOffset = Math.min(...positionsPlayedOff) - 1;
     }
@@ -40571,8 +40594,6 @@ function generateDrawStructuresAndLinks$1(params) {
   const {
     enforceMinimumDrawSize = true,
     overwriteExisting,
-    drawTypeCoercion,
-    // coerce to SINGLE_ELIMINATION for drawSize: 2
     appliedPolicies,
     staggeredEntry,
     // optional - specifies main structure FEED_IN for drawTypes CURTIS_CONSOLATION, FEED_IN_CHAMPIONSHIPS, FMLC
@@ -40582,8 +40603,9 @@ function generateDrawStructuresAndLinks$1(params) {
     isMock,
     uuids
   } = params || {};
+  const drawTypeCoercion = params.drawTypeCoercion ?? appliedPolicies?.[POLICY_TYPE_DRAWS]?.drawTypeCoercion ?? true;
   const stack = "generateDrawStructuresAndLinks";
-  let drawType = params.drawType ?? SINGLE_ELIMINATION;
+  let drawType = drawTypeCoercion && params.drawSize === 2 && DrawTypeEnum.SingleElimination || params.drawType || DrawTypeEnum.SingleElimination;
   const structures = [], links = [];
   const matchUpType = params?.matchUpType ?? SINGLES$1;
   const existingQualifyingStructures = drawDefinition?.structures?.filter(
@@ -48690,25 +48712,19 @@ const drawEngine = function() {
   return engine;
   function importGovernors(governors) {
     governors.forEach((governor) => {
-      Object.keys(governor).forEach((governorMethod) => {
-        engine[governorMethod] = (params) => {
+      Object.keys(governor).forEach((methodName) => {
+        engine[methodName] = (params) => {
           if (getDevContext()) {
-            return invoke({ params, governor, governorMethod });
+            return invoke({ params, governor, methodName });
           } else {
             try {
-              return invoke({ params, governor, governorMethod });
+              return invoke({ params, governor, methodName });
             } catch (err) {
-              let error;
-              if (typeof err === "string") {
-                error = err.toUpperCase();
-              } else if (err instanceof Error) {
-                error = err.message;
-              }
-              console.log("ERROR", {
-                params: JSON.stringify(params),
-                drawId: drawDefinition$1?.drawId,
-                method: governorMethod,
-                error
+              handleCaughtError({
+                engineName: "drawEngine",
+                methodName,
+                params,
+                err
               });
             }
           }
@@ -48716,7 +48732,7 @@ const drawEngine = function() {
       });
     });
   }
-  function invoke({ params, governor, governorMethod }) {
+  function invoke({ params, governor, methodName }) {
     delete engine.success;
     delete engine.error;
     const snapshot = params?.rollbackOnError && makeDeepCopy(drawDefinition$1, false, true);
@@ -48727,7 +48743,7 @@ const drawEngine = function() {
       tournamentParticipants: tournamentParticipants$1,
       drawDefinition: drawDefinition$1
     };
-    const result = governor[governorMethod](params);
+    const result = governor[methodName](params);
     if (result?.error) {
       if (snapshot)
         setState$3(snapshot);
@@ -48820,25 +48836,19 @@ function drawEngineAsync(test) {
   async function importGovernors(governors) {
     for (const governor of governors) {
       const governorMethods = Object.keys(governor);
-      for (const governorMethod of governorMethods) {
-        engine[governorMethod] = async (params) => {
+      for (const methodName of governorMethods) {
+        engine[methodName] = async (params) => {
           if (getDevContext()) {
-            return await invoke({ params, governor, governorMethod });
+            return await invoke({ params, governor, methodName });
           } else {
             try {
-              return await invoke({ params, governor, governorMethod });
+              return await invoke({ params, governor, methodName });
             } catch (err) {
-              let error;
-              if (typeof err === "string") {
-                error = err.toUpperCase();
-              } else if (err instanceof Error) {
-                error = err.message;
-              }
-              console.log("ERROR", {
-                params: JSON.stringify(params),
-                drawId: drawDefinition?.drawId,
-                method: governorMethod,
-                error
+              handleCaughtError({
+                engineName: "drawEngine",
+                methodName,
+                params,
+                err
               });
             }
           }
@@ -48846,7 +48856,7 @@ function drawEngineAsync(test) {
       }
     }
   }
-  async function invoke({ params, governor, governorMethod }) {
+  async function invoke({ params, governor, methodName }) {
     delete engine.success;
     delete engine.error;
     const snapshot = params?.rollbackOnError && makeDeepCopy(drawDefinition, false, true);
@@ -48857,7 +48867,7 @@ function drawEngineAsync(test) {
       tournamentParticipants,
       drawDefinition
     };
-    const result2 = governor[governorMethod](params);
+    const result2 = governor[methodName](params);
     if (result2?.error) {
       if (snapshot)
         setState$3(snapshot);
@@ -49355,24 +49365,19 @@ const matchUpEngine = (() => {
   return engine;
   function importGovernors(governors) {
     governors.forEach((governor) => {
-      Object.keys(governor).forEach((governorMethod) => {
-        engine[governorMethod] = (params) => {
+      Object.keys(governor).forEach((methodName) => {
+        engine[methodName] = (params) => {
           if (getDevContext()) {
-            return invoke({ params, governor, governorMethod });
+            return invoke({ params, governor, methodName });
           } else {
             try {
-              return invoke({ params, governor, governorMethod });
+              return invoke({ params, governor, methodName });
             } catch (err) {
-              let error;
-              if (typeof err === "string") {
-                error = err.toUpperCase();
-              } else if (err instanceof Error) {
-                error = err.message;
-              }
-              console.log("ERROR", {
-                params: JSON.stringify(params),
-                method: governorMethod,
-                error
+              handleCaughtError({
+                engineName: "matchUpEngine",
+                methodName,
+                params,
+                err
               });
             }
           }
@@ -49380,7 +49385,7 @@ const matchUpEngine = (() => {
       });
     });
   }
-  function invoke({ params, governor, governorMethod }) {
+  function invoke({ params, governor, methodName }) {
     engine.error = void 0;
     engine.success = false;
     const matchUp = params?.matchUp || getMatchUp();
@@ -49392,7 +49397,7 @@ const matchUpEngine = (() => {
       matchUps,
       matchUp
     };
-    const result = governor[governorMethod](params);
+    const result = governor[methodName](params);
     if (result?.error) {
       if (snapshot)
         setState$2(snapshot);
@@ -49452,24 +49457,19 @@ function matchUpEngineAsync(test) {
   async function importGovernors(governors) {
     for (const governor of governors) {
       const governorMethods = Object.keys(governor);
-      for (const governorMethod of governorMethods) {
-        engine[governorMethod] = async (params) => {
+      for (const methodName of governorMethods) {
+        engine[methodName] = async (params) => {
           if (getDevContext()) {
-            return await invoke({ params, governor, governorMethod });
+            return await invoke({ params, governor, methodName });
           } else {
             try {
-              return await invoke({ params, governor, governorMethod });
+              return await invoke({ params, governor, methodName });
             } catch (err) {
-              let error;
-              if (typeof err === "string") {
-                error = err.toUpperCase();
-              } else if (err instanceof Error) {
-                error = err.message;
-              }
-              console.log("ERROR", {
-                params: JSON.stringify(params),
-                method: governorMethod,
-                error
+              handleCaughtError({
+                engineName: "matchUpEngine",
+                methodName,
+                params,
+                err
               });
             }
           }
@@ -49477,7 +49477,7 @@ function matchUpEngineAsync(test) {
       }
     }
   }
-  async function invoke({ params, governor, governorMethod }) {
+  async function invoke({ params, governor, methodName }) {
     engine.success = false;
     engine.error = void 0;
     const matchUp = params?.matchUp || getMatchUp();
@@ -49489,7 +49489,7 @@ function matchUpEngineAsync(test) {
       matchUps,
       matchUp
     };
-    const result2 = governor[governorMethod](params);
+    const result2 = governor[methodName](params);
     if (result2?.error) {
       if (snapshot)
         setState$2(snapshot);
@@ -54724,7 +54724,10 @@ function addEventEntryPairs({
     event
   });
   if (newParticipants.length) {
-    addNotice({ topic: ADD_PARTICIPANTS, participants: newParticipants });
+    addNotice({
+      payload: { participants: newParticipants },
+      topic: ADD_PARTICIPANTS
+    });
   }
   const newParticipantIds = newParticipants.map(getParticipantId);
   return { ...result, info, newParticipantIds };
@@ -54732,9 +54735,12 @@ function addEventEntryPairs({
 
 function checkValidEntries({
   enforceGender = true,
+  consideredEntries,
+  tournamentRecord,
   participants,
   event
 }) {
+  participants = participants || tournamentRecord?.participants;
   if (!participants)
     return { error: MISSING_PARTICIPANTS };
   if (!Array.isArray(participants))
@@ -54745,7 +54751,7 @@ function checkValidEntries({
   const participantType = eventType === TEAM_EVENT && TEAM || eventType === DOUBLES_EVENT && PAIR || INDIVIDUAL;
   const entryStatusMap = Object.assign(
     {},
-    ...(event.entries || []).map((entry) => ({
+    ...(consideredEntries || event.entries || []).map((entry) => ({
       [entry.participantId]: entry.entryStatus
     }))
   );
@@ -57338,7 +57344,6 @@ function prepareStage(params) {
 function generateDrawDefinition(params) {
   const stack = "generateDrawDefinition";
   const {
-    drawType = DrawTypeEnum.SingleElimination,
     considerEventEntries = true,
     // in the absence of drawSize and drawEntries, look to event.entries
     ignoreAllowedDrawTypes,
@@ -57354,18 +57359,17 @@ function generateDrawDefinition(params) {
     placeByes,
     event
   } = params;
-  const { tournamentParticipants: participants } = getTournamentParticipants({
-    tournamentRecord,
-    inContext: true
-  });
   const appliedPolicies = getAppliedPolicies({
     tournamentRecord,
     event
   }).appliedPolicies ?? {};
+  const drawTypeCoercion = params.drawTypeCoercion ?? appliedPolicies?.[POLICY_TYPE_DRAWS]?.drawTypeCoercion ?? true;
+  const drawType = drawTypeCoercion && params.drawSize === 2 && DrawTypeEnum.SingleElimination || params.drawType || DrawTypeEnum.SingleElimination;
+  const { tournamentParticipants: participants } = getTournamentParticipants({
+    tournamentRecord,
+    inContext: true
+  });
   const enforceGender = params.enforceGender ?? policyDefinitions?.[POLICY_TYPE_MATCHUP_ACTIONS]?.participants?.enforceGender ?? appliedPolicies?.[POLICY_TYPE_MATCHUP_ACTIONS]?.participants?.enforceGender;
-  const validEntriesResult = event && participants && checkValidEntries({ event, participants, enforceGender });
-  if (validEntriesResult?.error)
-    return decorateResult({ result: validEntriesResult, stack });
   const allowedDrawTypes = !ignoreAllowedDrawTypes && tournamentRecord && getAllowedDrawTypes({
     tournamentRecord,
     categoryType: event?.category?.categoryType,
@@ -57378,6 +57382,14 @@ function generateDrawDefinition(params) {
     (entry) => entry.entryStatus && [...STRUCTURE_ENTERED_TYPES, QUALIFIER].includes(entry.entryStatus)
   ) ?? [];
   const consideredEntries = (qualifyingOnly && [] || drawEntries || (considerEventEntries ? eventEntries : [])).filter(({ entryStage }) => !entryStage || entryStage === MAIN);
+  const validEntriesResult = event && participants && checkValidEntries({
+    consideredEntries,
+    enforceGender,
+    participants,
+    event
+  });
+  if (validEntriesResult?.error)
+    return decorateResult({ result: validEntriesResult, stack });
   const derivedDrawSize = !params.drawSize && consideredEntries.length && ![
     AD_HOC,
     DOUBLE_ELIMINATION,
@@ -58735,17 +58747,11 @@ const tournamentEngine = (() => {
             try {
               return engineInvoke(governor[methodName], params, methodName);
             } catch (err) {
-              let error;
-              if (typeof err === "string") {
-                error = err.toUpperCase();
-              } else if (err instanceof Error) {
-                error = err.message;
-              }
-              console.log("ERROR", {
-                tournamentId: getTournamentId(),
-                params: JSON.stringify(params),
+              handleCaughtError({
+                engineName: "tournamentEngine",
                 methodName,
-                error
+                params,
+                err
               });
             }
           }
@@ -58906,26 +58912,19 @@ function tournamentEngineAsync(test) {
   function importGovernors(governors) {
     for (const governor of governors) {
       const governorMethods = Object.keys(governor);
-      for (const method of governorMethods) {
-        engine[method] = async (params) => {
+      for (const methodName of governorMethods) {
+        engine[methodName] = async (params) => {
           if (getDevContext()) {
-            return await engineInvoke(governor[method], params);
+            return await engineInvoke(governor[methodName], params);
           } else {
             try {
-              return await engineInvoke(governor[method], params);
+              return await engineInvoke(governor[methodName], params);
             } catch (err) {
-              const tournamentId = getTournamentId();
-              let error;
-              if (typeof err === "string") {
-                error = err.toUpperCase();
-              } else if (err instanceof Error) {
-                error = err.message;
-              }
-              console.log("ERROR", {
-                params: JSON.stringify(params),
-                tournamentId,
-                method,
-                error
+              handleCaughtError({
+                engineName: "tournamentEngine",
+                methodName,
+                params,
+                err
               });
             }
           }
@@ -59624,24 +59623,19 @@ const scaleEngine = (() => {
   }
   function importGovernors(governors) {
     governors.forEach((governor) => {
-      Object.keys(governor).forEach((method) => {
-        engine[method] = (params) => {
+      Object.keys(governor).forEach((methodName) => {
+        engine[methodName] = (params) => {
           if (getDevContext()) {
-            return engineInvoke(governor[method], params);
+            return engineInvoke(governor[methodName], params);
           } else {
             try {
-              return engineInvoke(governor[method], params);
+              return engineInvoke(governor[methodName], params);
             } catch (err) {
-              let error;
-              if (typeof err === "string") {
-                error = err.toUpperCase();
-              } else if (err instanceof Error) {
-                error = err.message;
-              }
-              console.log("ERROR", {
-                error,
-                method,
-                params: JSON.stringify(params)
+              handleCaughtError({
+                engineName: "scaleEngine",
+                methodName,
+                params,
+                err
               });
             }
           }
@@ -59713,9 +59707,22 @@ function scaleEngineAsync(test) {
   function importGovernors(governors) {
     for (const governor of governors) {
       const governorMethods = Object.keys(governor);
-      for (const governorMethod of governorMethods) {
-        engine[governorMethod] = async (params) => {
-          return await engineInvoke(governor[governorMethod], params);
+      for (const methodName of governorMethods) {
+        engine[methodName] = async (params) => {
+          if (getDevContext()) {
+            return await engineInvoke(governor[methodName], params);
+          } else {
+            try {
+              return await engineInvoke(governor[methodName], params);
+            } catch (err) {
+              handleCaughtError({
+                engineName: "scaleEngine",
+                methodName,
+                params,
+                err
+              });
+            }
+          }
         };
       }
     }