tods-competition-factory 1.6.29 → 1.7.0

package/dist/index.mjs

@@ -329,7 +329,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.6.29";
+  return "1.7.0";
 }
 
 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
               });
             }
           }
@@ -40570,8 +40593,6 @@ function getGenerators(params) {
 function generateDrawStructuresAndLinks$1(params) {
   const {
     enforceMinimumDrawSize = true,
-    drawTypeCoercion = true,
-    // coerce to SINGLE_ELIMINATION for drawSize: 2
     overwriteExisting,
     appliedPolicies,
     staggeredEntry,
@@ -40582,6 +40603,7 @@ function generateDrawStructuresAndLinks$1(params) {
     isMock,
     uuids
   } = params || {};
+  const drawTypeCoercion = params.drawTypeCoercion ?? appliedPolicies?.[POLICY_TYPE_DRAWS]?.drawTypeCoercion ?? true;
   const stack = "generateDrawStructuresAndLinks";
   let drawType = drawTypeCoercion && params.drawSize === 2 && DrawTypeEnum.SingleElimination || params.drawType || DrawTypeEnum.SingleElimination;
   const structures = [], links = [];
@@ -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 };
@@ -57343,7 +57346,6 @@ function generateDrawDefinition(params) {
   const {
     considerEventEntries = true,
     // in the absence of drawSize and drawEntries, look to event.entries
-    drawTypeCoercion = true,
     ignoreAllowedDrawTypes,
     voluntaryConsolation,
     hydrateCollections,
@@ -57357,15 +57359,16 @@ function generateDrawDefinition(params) {
     placeByes,
     event
   } = params;
+  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 appliedPolicies = getAppliedPolicies({
-    tournamentRecord,
-    event
-  }).appliedPolicies ?? {};
   const enforceGender = params.enforceGender ?? policyDefinitions?.[POLICY_TYPE_MATCHUP_ACTIONS]?.participants?.enforceGender ?? appliedPolicies?.[POLICY_TYPE_MATCHUP_ACTIONS]?.participants?.enforceGender;
   const allowedDrawTypes = !ignoreAllowedDrawTypes && tournamentRecord && getAllowedDrawTypes({
     tournamentRecord,
@@ -58744,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
               });
             }
           }
@@ -58915,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
               });
             }
           }
@@ -59633,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
               });
             }
           }
@@ -59722,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
+              });
+            }
+          }
         };
       }
     }