tods-competition-factory 1.8.2 → 1.8.4

package/dist/forge/utilities.mjs

@@ -127,10 +127,174 @@ function chunkByNth(arr, chunksCount, shuttle) {
   }, []);
 }
 
+const SUCCESS = { success: true };
+
+const MISSING_TOURNAMENT_RECORD = {
+  message: "Missing tournamentRecord",
+  code: "ERR_MISSING_TOURNAMENT"
+};
+const INVALID_TOURNAMENT_RECORD = {
+  message: "Invalid tournamentRecord",
+  code: "ERR_INVALID_TOURNAMENT"
+};
 const INVALID_VALUES = {
   message: "Invalid values",
   code: "ERR_INVALID_VALUES"
 };
+const NOT_FOUND = { message: "Not found", code: "ERR_NOT_FOUND" };
+
+const syncGlobalState = {
+  disableNotifications: false,
+  tournamentId: void 0,
+  tournamentRecords: {},
+  subscriptions: {},
+  modified: false,
+  notices: []
+};
+var syncGlobalState$1 = {
+  addNotice,
+  callListener,
+  cycleMutationStatus,
+  deleteNotice,
+  deleteNotices,
+  disableNotifications,
+  enableNotifications,
+  getNotices,
+  getTopics,
+  getTournamentId,
+  getTournamentRecord,
+  getTournamentRecords,
+  removeTournamentRecord,
+  setSubscriptions,
+  setTournamentId,
+  setTournamentRecord,
+  setTournamentRecords,
+  handleCaughtError
+};
+function disableNotifications() {
+  syncGlobalState.disableNotifications = true;
+}
+function enableNotifications() {
+  syncGlobalState.disableNotifications = false;
+}
+function getTournamentId() {
+  return syncGlobalState.tournamentId;
+}
+function getTournamentRecord(tournamentId) {
+  return syncGlobalState.tournamentRecords[tournamentId];
+}
+function getTournamentRecords() {
+  return syncGlobalState.tournamentRecords;
+}
+function setTournamentRecord(tournamentRecord) {
+  const tournamentId = tournamentRecord?.tournamentId;
+  if (tournamentId) {
+    syncGlobalState.tournamentRecords[tournamentId] = tournamentRecord;
+    return { success: true };
+  } else {
+    return { error: INVALID_TOURNAMENT_RECORD };
+  }
+}
+function setTournamentId(tournamentId) {
+  if (syncGlobalState.tournamentRecords[tournamentId]) {
+    syncGlobalState.tournamentId = tournamentId;
+    return { success: true };
+  } else {
+    return { error: MISSING_TOURNAMENT_RECORD };
+  }
+}
+function setTournamentRecords(tournamentRecords) {
+  syncGlobalState.tournamentRecords = tournamentRecords;
+  const tournamentIds = Object.keys(tournamentRecords);
+  if (tournamentIds.length === 1) {
+    syncGlobalState.tournamentId = tournamentIds[0];
+  } else if (!tournamentIds.length) {
+    syncGlobalState.tournamentId = void 0;
+  }
+}
+function removeTournamentRecord(tournamentId) {
+  if (typeof tournamentId !== "string")
+    return { error: INVALID_VALUES };
+  if (!syncGlobalState.tournamentRecords[tournamentId])
+    return { error: NOT_FOUND };
+  delete syncGlobalState.tournamentRecords[tournamentId];
+  const tournamentIds = Object.keys(syncGlobalState.tournamentRecords);
+  if (tournamentIds.length === 1) {
+    syncGlobalState.tournamentId = tournamentIds[0];
+  } else if (!tournamentIds.length) {
+    syncGlobalState.tournamentId = void 0;
+  }
+  return { success: true };
+}
+function setSubscriptions(params) {
+  if (typeof params.subscriptions !== "object")
+    return { error: INVALID_VALUES };
+  Object.keys(params.subscriptions).forEach((subscription) => {
+    syncGlobalState.subscriptions[subscription] = params.subscriptions[subscription];
+  });
+  return { ...SUCCESS };
+}
+function cycleMutationStatus() {
+  const status = syncGlobalState.modified;
+  syncGlobalState.modified = false;
+  return status;
+}
+function addNotice({ topic, payload, key }) {
+  syncGlobalState.modified = true;
+  if (typeof topic !== "string" || typeof payload !== "object") {
+    return;
+  }
+  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 });
+}
+function getNotices({ topic }) {
+  const notices = syncGlobalState.notices.filter((notice) => notice.topic === topic).map((notice) => notice.payload);
+  return notices.length && notices;
+}
+function deleteNotices() {
+  syncGlobalState.notices = [];
+}
+function deleteNotice({ topic, key }) {
+  syncGlobalState.notices = syncGlobalState.notices.filter(
+    (notice) => (!topic || notice.topic === topic) && notice.key !== key
+  );
+}
+function getTopics() {
+  const topics = Object.keys(syncGlobalState.subscriptions);
+  return { topics };
+}
+function callListener({ topic, notices }) {
+  const method = syncGlobalState.subscriptions[topic];
+  if (method && typeof method === "function") {
+    method(notices);
+  }
+}
+function handleCaughtError({
+  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(),
+    params: JSON.stringify(params),
+    engine: engineName,
+    methodName,
+    error
+  });
+}
 
 const globalState = {
   tournamentFactoryVersion: "0.0.0",
@@ -143,6 +307,7 @@ const globalState = {
   },
   deepCopy: true
 };
+let _globalStateProvider = syncGlobalState$1;
 function getDevContext(contextCriteria) {
   if (!contextCriteria || typeof contextCriteria !== "object") {
     return globalState.devContext ?? false;
@@ -163,6 +328,9 @@ function deepCopyEnabled() {
     ...globalState.deepCopyAttributes
   };
 }
+function getProvider() {
+  return _globalStateProvider;
+}
 
 function isDateObject(value) {
   if (typeof value !== "object" || Array.isArray(value)) {
@@ -174,6 +342,13 @@ function isDateObject(value) {
 }
 
 function makeDeepCopy(sourceObject, convertExtensions, internalUse, removeExtensions, iteration = 0) {
+  if (getProvider().makeDeepCopy)
+    return getProvider().makeDeepCopy(
+      sourceObject,
+      convertExtensions,
+      internalUse,
+      removeExtensions
+    );
   const deepCopy = deepCopyEnabled();
   const { stringify, toJSON, ignore, modulate } = deepCopy || {};
   if (!deepCopy?.enabled && !internalUse || typeof sourceObject !== "object" || typeof sourceObject === "function" || sourceObject === null || typeof deepCopy?.threshold === "number" && iteration >= deepCopy.threshold) {