tods-competition-factory 2.0.50 → 2.0.52

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.0.50';
+    return '2.0.52';
 }
 
 function isFunction(obj) {
@@ -1783,9 +1783,35 @@ function decorateResult({ context, result, stack, info }) {
     return result ?? { success: true };
 }
 
+const RESOURCE_SUB_TYPE = 'resourceSubType';
+const RESOURCE_TYPE = 'resourceType';
+const IDENTIFIER = 'identifier';
+
+const SINGLES$1 = 'SINGLES';
+const SINGLES_EVENT = 'SINGLES';
+const DOUBLES$1 = 'DOUBLES';
+const DOUBLES_EVENT = 'DOUBLES';
+const TEAM$2 = 'TEAM';
+const TEAM_EVENT = 'TEAM';
+const AGE = 'AGE';
+const RATING$2 = 'RATING';
+const BOTH = 'BOTH';
+const eventConstants = {
+    AGE,
+    BOTH,
+    DOUBLES: DOUBLES$1,
+    DOUBLES_EVENT,
+    RATING: RATING$2,
+    SINGLES: SINGLES$1,
+    SINGLES_EVENT,
+    TEAM_EVENT,
+    TEAM: TEAM$2,
+};
+
 const TOURNAMENT_RECORDS = 'tournamentRecords';
 const POLICY_DEFINITIONS = 'policyDefinitions';
 const TOURNAMENT_RECORD = 'tournamentRecord';
+const ONLINE_RESOURCE = 'onlineResource';
 const DRAW_DEFINITION = 'drawDefinition';
 const MATCHUP_FORMAT = 'matchUpFormat';
 const PARTICIPANT_ID = 'participantId';
@@ -1798,6 +1824,7 @@ const MATCHUP_IDS = 'matchUpIds';
 const POLICY_TYPE = 'policyType';
 const STRUCTURES = 'structures';
 const MATCHUP_ID = 'matchUpId';
+const EVENT_TYPE = 'eventType';
 const IN_CONTEXT = 'inContext';
 const STRUCTURE = 'structure';
 const COURT_IDS = 'courtIds';
@@ -1825,6 +1852,10 @@ const OF_TYPE = '_ofType';
 const ANY_OF = '_anyOf';
 const ONE_OF = '_oneOf';
 
+const validators = {
+    [EVENT_TYPE]: (value) => [SINGLES$1, DOUBLES$1, TEAM$2].includes(value),
+    [ONLINE_RESOURCE]: (value) => intersection(Object.keys(value), [RESOURCE_SUB_TYPE, RESOURCE_TYPE, IDENTIFIER]).length === 3,
+};
 const errors = {
     [TOURNAMENT_RECORDS]: MISSING_TOURNAMENT_RECORDS,
     [TOURNAMENT_RECORD]: MISSING_TOURNAMENT_RECORD,
@@ -1836,6 +1867,8 @@ const errors = {
     [STRUCTURE_ID]: MISSING_STRUCTURE_ID,
     [MATCHUP_IDS]: MISSING_MATCHUP_IDS,
     [PARTICIPANT]: MISSING_PARTICIPANT,
+    [ONLINE_RESOURCE]: INVALID_OBJECT,
+    [EVENT_TYPE]: INVALID_EVENT_TYPE,
     [STRUCTURES]: MISSING_STRUCTURES,
     [MATCHUP_ID]: MISSING_MATCHUP_ID,
     [STRUCTURE]: MISSING_STRUCTURE,
@@ -1853,6 +1886,7 @@ const paramTypes = {
     [POLICY_DEFINITIONS]: OBJECT,
     [TOURNAMENT_RECORD]: OBJECT,
     [DRAW_DEFINITION]: OBJECT,
+    [ONLINE_RESOURCE]: OBJECT,
     [SCHEDULE_DATES]: ARRAY,
     [PARTICIPANT]: OBJECT,
     [MATCHUP_IDS]: ARRAY,
@@ -1923,7 +1957,9 @@ function findParamError(params, requiredParams) {
             const faliedTypeCheck = params[param] !== undefined && !_validate && invalidType(params, param, _ofType);
             const paramNotPresent = attrs[param] && [undefined, null].includes(params[param]);
             const invalid = invalidValidationFunction || faliedTypeCheck || paramNotPresent;
-            const hasError = invalid || (_validate && params[param] !== undefined && !checkValidation(params[param], _validate));
+            const hasError = invalid ||
+                (_validate && params[param] !== undefined && !checkValidation(params[param], _validate)) ||
+                (validators[param] && !validators[param](params[param]));
             if (hasError) {
                 errorParam = param;
                 paramInfo = _info;
@@ -1947,27 +1983,6 @@ function checkValidation(value, validate) {
     return true;
 }
 
-const SINGLES$1 = 'SINGLES';
-const SINGLES_EVENT = 'SINGLES';
-const DOUBLES$1 = 'DOUBLES';
-const DOUBLES_EVENT = 'DOUBLES';
-const TEAM$2 = 'TEAM';
-const TEAM_EVENT = 'TEAM';
-const AGE = 'AGE';
-const RATING$2 = 'RATING';
-const BOTH = 'BOTH';
-const eventConstants = {
-    AGE,
-    BOTH,
-    DOUBLES: DOUBLES$1,
-    DOUBLES_EVENT,
-    RATING: RATING$2,
-    SINGLES: SINGLES$1,
-    SINGLES_EVENT,
-    TEAM_EVENT,
-    TEAM: TEAM$2,
-};
-
 const DYNAMIC = 'DYNAMIC';
 const RANKING$1 = 'RANKING';
 const RATING$1 = 'RATING';
@@ -2710,8 +2725,8 @@ const APPLIED_POLICIES = 'appliedPolicies';
 const CONTEXT = 'context';
 const DELEGATED_OUTCOME = 'delegatedOutcome';
 const DISABLED = 'disabled';
-const DISABLE_LINKS = 'disableLinks';
 const DISABLE_AUTO_CALC = 'disableAutoCalc';
+const DISABLE_LINKS = 'disableLinks';
 const DISPLAY = 'display';
 const DRAW_DELETIONS = 'drawDeletions';
 const DRAW_PROFILE = 'drawProfile';
@@ -2728,6 +2743,7 @@ const PARTICIPANT_REPRESENTATIVES = 'participantRepresentatives';
 const PERSON_REQUESTS = 'personRequests';
 const POSITION_ACTIONS = 'positionActions';
 const RANKING_POINTS = 'rankingPoints';
+const REGISTRATION$1 = 'registration';
 const ROUND_TARGET = 'roundTarget';
 const SCHEDULE_LIMITS = 'scheduleLimits';
 const SCHEDULE_TIMING = 'scheduleTiming';
@@ -2759,6 +2775,7 @@ const extensionConstants = {
     PERSON_REQUESTS,
     POSITION_ACTIONS,
     RANKING_POINTS,
+    REGISTRATION: REGISTRATION$1,
     ROUND_TARGET,
     SCHEDULE_LIMITS,
     SCHEDULE_TIMING,
@@ -2772,9 +2789,11 @@ const extensionConstants = {
 const internalExtensions = [
     DELEGATED_OUTCOME,
     DISABLED,
+    DISABLE_AUTO_CALC,
     DISABLE_LINKS,
     FLIGHT_PROFILE,
     LINEUPS,
+    LINKED_TOURNAMENTS,
     MATCHUP_HISTORY,
     PARTICIPANT_REPRESENTATIVES,
     PERSON_REQUESTS,
@@ -2784,6 +2803,7 @@ const internalExtensions = [
     SCHEDULING_PROFILE,
     SUB_ORDER,
     TALLY,
+    TIE_FORMAT_MODIFICATIONS,
 ];
 
 function linkTournaments({ tournamentRecords }) {
@@ -26492,9 +26512,14 @@ function addParticipantScaleItem({ removePriorValues, participant, scaleItem })
     return { ...SUCCESS, valueChanged, newValue: scaleItem.scaleValue };
 }
 
-function addDynamicRatings({ tournamentRecord, modifiedScaleValues, removePriorValues }) {
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
+function addDynamicRatings(params) {
+    const { tournamentRecord, modifiedScaleValues, removePriorValues } = params;
+    const paramsCheck = checkRequiredParameters(params, [
+        { [TOURNAMENT_RECORD]: true },
+        { modifiedScaleValues: true, [OF_TYPE]: OBJECT },
+    ]);
+    if (paramsCheck.error)
+        return paramsCheck;
     for (const participantId in modifiedScaleValues) {
         const result = setParticipantScaleItem({
             scaleItem: modifiedScaleValues[participantId],
@@ -26628,19 +26653,19 @@ function generateDynamicRatings(params) {
     const ratingParameter = ratingsParameters[ratingType];
     const { accessor } = ratingParameter;
     const modifiedScaleValues = {};
-    const matchUps = params.matchUps ??
+    const matchUps = (params.matchUps ||
         (refreshDynamic &&
             allDrawMatchUps({
                 drawDefinition,
                 tournamentRecord,
                 inContext: true,
                 matchUpFilters: { matchUpStatuses: completedMatchUpStatuses },
-            })) ??
+            }).matchUps) ||
         allTournamentMatchUps({
             matchUpFilters: { matchUpIds, matchUpStatuses: completedMatchUpStatuses },
             tournamentRecord,
             inContext: true,
-        }).matchUps ??
+        }).matchUps) ??
         [];
     const dynamicScaleName = `${ratingType}.${DYNAMIC}`;
     const outputScaleName = asDynamic ? dynamicScaleName : ratingType;
@@ -26670,7 +26695,7 @@ function generateDynamicRatings(params) {
             .flat()
             .map((participantId) => {
             const existingModifiedScaleValue = modifiedScaleValues[participantId];
-            const useDynamic = !refreshDynamic || !existingModifiedScaleValue;
+            const useDynamic = !refreshDynamic || existingModifiedScaleValue;
             const dynamicScaleItem = useDynamic
                 ? getParticipantScaleItem({
                     scaleAttributes: dynamicScaleAttributes,
@@ -26998,7 +27023,8 @@ function getSideRatings({ tournamentParticipants, adHocRatings, eventType, scale
     });
 }
 
-function getPairings({ tournamentParticipants, adHocRatings = {}, possiblePairings, uniquePairings, maxIterations, deltaObjects, valueObjects, eventType, scaleName, salted, }) {
+function getPairings(params) {
+    const { tournamentParticipants, adHocRatings = {}, possiblePairings, uniquePairings, maxIterations, minimizeDelta, deltaObjects, valueObjects, eventType, scaleName, salted, } = params;
     uniquePairings.forEach((pairing) => {
         const ratings = getSideRatings({
             tournamentParticipants,
@@ -27030,7 +27056,7 @@ function getPairings({ tournamentParticipants, adHocRatings = {}, possiblePairin
         deltaObjects,
         valueObjects,
     });
-    const { participantIdPairings } = candidate;
+    const { participantIdPairings } = minimizeDelta ? deltaCandidate : candidate;
     return {
         participantIdPairings,
         candidatesCount,
@@ -27043,14 +27069,13 @@ function getPairings({ tournamentParticipants, adHocRatings = {}, possiblePairin
 const ENCOUNTER_VALUE = 100;
 const SAME_TEAM_VALUE = 100;
 const MAX_ITERATIONS = 4000;
-function generateDrawMaticRound({ encounterValue = ENCOUNTER_VALUE, sameTeamValue = SAME_TEAM_VALUE, maxIterations = MAX_ITERATIONS, updateParticipantRatings, generateMatchUps = true, ignoreLastRoundNumber, iterationMatchUps, tournamentRecord, dynamicRatings, refreshDynamic, participantIds, drawDefinition, adHocRatings, salted = 0.5, roundNumber, structureId, matchUpIds, eventType, structure, scaleName, idPrefix, isMock, event, }) {
+function generateDrawMaticRound(params) {
+    const { encounterValue = ENCOUNTER_VALUE, sameTeamValue = SAME_TEAM_VALUE, maxIterations = MAX_ITERATIONS, updateParticipantRatings, generateMatchUps = true, ignoreLastRoundNumber, iterationMatchUps, tournamentRecord, dynamicRatings, refreshDynamic, participantIds, drawDefinition, roundNumber, structureId, matchUpIds, eventType, scaleName, idPrefix, isMock, salted, event, } = params;
     if (!drawDefinition)
         return { error: MISSING_DRAW_DEFINITION };
-    if (!structure && !structureId)
+    if (!params.structure && !structureId)
         return { error: STRUCTURE_NOT_FOUND };
-    if (!structure) {
-        structure = findStructure({ drawDefinition, structureId }).structure;
-    }
+    const structure = params.structure || findStructure({ drawDefinition, structureId }).structure;
     if (!isObject(structure))
         return { error: MISSING_STRUCTURE };
     if (!participantIds?.length)
@@ -27067,7 +27092,7 @@ function generateDrawMaticRound({ encounterValue = ENCOUNTER_VALUE, sameTeamValu
                 ?.filter(({ roundNumber }) => roundNumber === lastRoundNumber)
                 .map(({ matchUpId }) => matchUpId);
             const result = generateDynamicRatings({
-                ratingType: scaleName || event?.category?.ratingType,
+                ratingType: scaleName ?? event?.category?.ratingType,
                 updateParticipantRatings,
                 tournamentRecord,
                 asDynamic: true,
@@ -27090,14 +27115,15 @@ function generateDrawMaticRound({ encounterValue = ENCOUNTER_VALUE, sameTeamValu
     const { uniquePairings, possiblePairings, deltaObjects } = getPairingsData({
         participantIds,
     });
-    const params = {
-        adHocRatings: modifiedScaleValues || adHocRatings,
+    const adHocRatings = Object.values(modifiedScaleValues).length ? modifiedScaleValues : params.adHocRatings;
+    const paringParams = {
         tournamentParticipants,
         possiblePairings,
-        drawDefinition,
         participantIds,
         uniquePairings,
+        drawDefinition,
         maxIterations,
+        adHocRatings,
         deltaObjects,
         valueObjects,
         eventType,
@@ -27105,7 +27131,7 @@ function generateDrawMaticRound({ encounterValue = ENCOUNTER_VALUE, sameTeamValu
         structure,
         salted,
     };
-    const { candidatesCount, participantIdPairings, iterations, candidate } = getPairings(params);
+    const { candidatesCount, participantIdPairings, deltaCandidate, iterations, candidate } = getPairings(paringParams);
     if (!candidatesCount)
         return { error: NO_CANDIDATES };
     let generatedRoundNumber;
@@ -27134,6 +27160,7 @@ function generateDrawMaticRound({ encounterValue = ENCOUNTER_VALUE, sameTeamValu
         participantIdPairings,
         modifiedScaleValues,
         candidatesCount,
+        deltaCandidate,
         ...SUCCESS,
         iterations,
         matchUps,
@@ -38134,17 +38161,19 @@ function modifyEventPublishStatus({ removePriorValues = true, status = PUBLIC, s
 }
 
 function publishEvent(params) {
+    const paramsCheck = checkRequiredParameters(params, [
+        { [TOURNAMENT_RECORD]: true, [EVENT]: true },
+        { eventDataParams: false, [OF_TYPE]: OBJECT },
+    ]);
+    if (paramsCheck.error)
+        return paramsCheck;
     const { includePositionAssignments, removePriorValues, tournamentRecord, status = PUBLIC, event, drawIdsToRemove, drawIdsToAdd, } = params;
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    if (!event)
-        return { error: MISSING_EVENT };
     const { appliedPolicies } = getAppliedPolicies({ tournamentRecord, event });
     const policyDefinitions = {
         ...appliedPolicies,
         ...params.policyDefinitions,
     };
-    const eventDrawIds = event.drawDefinitions?.map(({ drawId }) => drawId) ?? [];
+    const eventDrawIds = event?.drawDefinitions?.map(({ drawId }) => drawId) ?? [];
     const keyedDrawIds = params.drawDetails ? Object.keys(params.drawDetails) : [];
     const specifiedDrawIds = keyedDrawIds.length ? [] : params.drawIds;
     const drawIdsToValidate = (drawIdsToAdd ?? []).concat(...(drawIdsToRemove ?? []), ...(specifiedDrawIds ?? []), ...keyedDrawIds);
@@ -38190,7 +38219,7 @@ function publishEvent(params) {
                 stageDetails,
             };
             if (structureIdsToAdd.length || structureIdsToRemove.length) {
-                const drawStructureIds = (event.drawDefinitions?.find((drawDefinition) => drawDefinition.drawId === drawId)?.structures ?? []).map(({ structureId }) => structureId);
+                const drawStructureIds = (event?.drawDefinitions?.find((drawDefinition) => drawDefinition.drawId === drawId)?.structures ?? []).map(({ structureId }) => structureId);
                 const structureIdsToValidate = (structureIdsToAdd ?? []).concat(structureIdsToRemove ?? []);
                 const invalidStructureIds = structureIdsToValidate.filter((structureId) => !drawStructureIds.includes(structureId));
                 if (invalidStructureIds.length) {
@@ -38210,7 +38239,7 @@ function publishEvent(params) {
                 }
                 drawDetails[drawId].structureDetails = structureDetails;
             }
-            const drawStages = (event.drawDefinitions?.find((drawDefinition) => drawDefinition.drawId === drawId)?.structures ?? []).map(({ stage }) => stage);
+            const drawStages = (event?.drawDefinitions?.find((drawDefinition) => drawDefinition.drawId === drawId)?.structures ?? []).map(({ stage }) => stage);
             if (stagesToAdd.length) {
                 for (const stage of stagesToAdd) {
                     stageDetails[stage] = { published: true };
@@ -38247,6 +38276,7 @@ function publishEvent(params) {
     const eventData = notify || params.returnEventData
         ? getEventData({
             includePositionAssignments,
+            ...params.eventDataParams,
             usePublishState: true,
             tournamentRecord,
             policyDefinitions,
@@ -38429,6 +38459,7 @@ function deleteDrawDefinitions(params) {
     addDrawDeletionTelemetry({ appliedPolicies, event, deletedDrawsDetail, auditData });
     if (autoPublish && publishedDrawsDeleted) {
         const result = publishEvent({
+            ...params.eventDataParams,
             drawIdsToRemove: drawIds,
             policyDefinitions,
             tournamentRecord,
@@ -47564,8 +47595,8 @@ function nameMocks({ nameRoot = 'TEAM', count = 1 } = {}) {
 }
 
 function generateParticipants(params) {
-    let { rankingRange, scaledParticipantsCount, } = params;
-    const { ratingsParameters: ratingsParameters$1 = ratingsParameters, valuesInstanceLimit, consideredDate, category, nationalityCodesCount, nationalityCodeType, nationalityCodes, participantsCount = 32, participantType, personIds, idPrefix, uuids, personExtensions, addressProps, gendersCount, matchUpType, personData, sex, inContext, withISO2, withIOC, scaleAllParticipants, } = params;
+    let { scaledParticipantsCount, rankingRange, } = params;
+    const { ratingsParameters: ratingsParameters$1 = ratingsParameters, valuesInstanceLimit, ratingsValues = [], consideredDate, categories, category, nationalityCodesCount, nationalityCodeType, nationalityCodes, participantsCount = 32, participantType, personIds, idPrefix, uuids, personExtensions, addressProps, gendersCount, matchUpType, personData, sex, inContext, withISO2, withIOC, scaleAllParticipants, } = params;
     const doubles = participantType === PAIR || matchUpType === DOUBLES_MATCHUP;
     const team = participantType === TEAM || matchUpType === TEAM;
     if (rankingRange &&
@@ -47592,57 +47623,36 @@ function generateParticipants(params) {
     if (result.error)
         return result;
     const { nationalityCodes: personNationalityCodes, persons: mockedPersons } = result;
-    let doublesRankings = [], singlesRankings = [], singlesRatings = [], doublesRatings = [];
-    if (typeof category === 'object') {
-        const { categoryName, ageCategoryCode, ratingType } = category;
-        if ((categoryName || ageCategoryCode) && !ratingType) {
-            const [start, end] = rankingRange || [];
-            singlesRankings = shuffleArray(generateRange(start, end)).slice(0, scaledParticipantsCount || randomInt(20, 30));
-            if ([PAIR, TEAM].includes(participantType)) {
-                const [start, end] = rankingRange || [];
-                doublesRankings = shuffleArray(generateRange(start, end)).slice(0, scaledParticipantsCount || randomInt(20, 30));
-            }
-        }
-        if (ratingType && ratingsParameters$1[ratingType]) {
-            const { ratingMax, ratingMin, ratingAttributes } = category;
-            const ratingParameters = {
-                ...ratingsParameters$1[ratingType],
-                ...(ratingAttributes || {}),
-            };
-            const { attributes = {}, decimalsCount, accessors, range, step } = ratingParameters;
-            const getAttributes = (attributes) => {
-                const generatedAttributes = {};
-                const attributeKeys = Object.keys(attributes || {});
-                for (const attribute of attributeKeys) {
-                    const attributeValue = attributes[attribute];
-                    if (typeof attributeValue === 'object' && attributeValue.generator) {
-                        const { range } = attributeValue;
-                        const [min, max] = range.slice().sort();
-                        generatedAttributes[attribute] = randomInt(min, max);
-                    }
-                    else {
-                        generatedAttributes[attribute] = attributeValue;
-                    }
-                }
-                return generatedAttributes;
-            };
-            const inverted = range[0] > range[1];
-            const skew = inverted ? 2 : 0.5;
-            const [min, max] = range.slice().sort();
-            const generateRatings = () => generateRange(0, 2000)
-                .map(() => skewedDistribution(min, max, skew, step, decimalsCount))
-                .filter((rating) => (!ratingMax || rating <= ratingMax) && (!ratingMin || rating >= ratingMin))
-                .slice(0, scaledParticipantsCount || randomInt(20, 30))
-                .map((scaleValue) => {
-                return !accessors
-                    ? scaleValue
-                    : Object.assign({}, ...accessors.map((accessor) => ({ [accessor]: scaleValue })), getAttributes(attributes));
+    const doublesRankings = {}, singlesRankings = {}, singlesRatings = {}, doublesRatings = {};
+    const assignResult = (result) => {
+        Object.assign(doublesRankings, result.doublesRankings);
+        Object.assign(singlesRankings, result.singlesRankings);
+        Object.assign(doublesRatings, result.doublesRatings);
+        Object.assign(singlesRatings, result.singlesRatings);
+    };
+    if (isObject(category)) {
+        const result = genRatings({
+            scaledParticipantsCount,
+            ratingsParameters: ratingsParameters$1,
+            participantType,
+            ratingsValues,
+            rankingRange,
+            category,
+        });
+        assignResult(result);
+    }
+    if (Array.isArray(categories)) {
+        categories.forEach((category) => {
+            const result = genRatings({
+                scaledParticipantsCount,
+                ratingsParameters: ratingsParameters$1,
+                participantType,
+                ratingsValues,
+                rankingRange,
+                category,
             });
-            singlesRatings = generateRatings();
-            if ([PAIR, TEAM].includes(participantType)) {
-                doublesRatings = generateRatings();
-            }
-        }
+            assignResult(result);
+        });
     }
     const countryCodes = countries.filter((country) => nationalityCodeType === 'IOC' ? country.ioc || country.iso : country.iso);
     function getMin(count) {
@@ -47767,9 +47777,10 @@ function generateParticipants(params) {
             if (country?.label)
                 participant.person.countryName = country.label;
         }
-        if (category) {
-            const singlesRanking = singlesRankings[participantIndex];
-            const doublesRanking = doublesRankings[participantIndex];
+        const processCategory = (category) => {
+            const scaleName = category.categoryName || category.ratingType || category.ageCategoryCode;
+            const singlesRanking = singlesRankings[scaleName]?.[participantIndex];
+            const doublesRanking = doublesRankings[scaleName]?.[participantIndex];
             addScaleItem({
                 scaleValue: singlesRanking,
                 eventType: SINGLES_EVENT,
@@ -47784,8 +47795,8 @@ function generateParticipants(params) {
                 participant,
                 category,
             });
-            const singlesRating = singlesRatings[participantIndex];
-            const doublesRating = doublesRatings[participantIndex];
+            const singlesRating = singlesRatings[scaleName]?.[participantIndex];
+            const doublesRating = doublesRatings[scaleName]?.[participantIndex];
             addScaleItem({
                 scaleValue: singlesRating,
                 eventType: SINGLES_EVENT,
@@ -47800,6 +47811,12 @@ function generateParticipants(params) {
                 participant,
                 category,
             });
+        };
+        if (Array.isArray(categories)) {
+            categories.forEach((category) => processCategory(category));
+        }
+        else if (category) {
+            processCategory(category);
         }
         return participant;
     }
@@ -47814,6 +47831,66 @@ function addScaleItem({ scaleValue: itemValue, participant, eventType, scaleType
         participant.timeItems.push(timeItem);
     }
 }
+function genRatings(params) {
+    const { category, scaledParticipantsCount, ratingsParameters, participantType, ratingsValues = [] } = params;
+    const rankingRange = category.rankingRange || params.rankingRange || [1, 1000];
+    const doublesRankings = {}, singlesRankings = {}, singlesRatings = {}, doublesRatings = {};
+    const { categoryName, ageCategoryCode, ratingType } = category;
+    const scaleName = category.categoryName || category.ratingType || category.ageCategoryCode;
+    if ((categoryName || ageCategoryCode) && !ratingType) {
+        const [start, end] = rankingRange || [];
+        singlesRankings[scaleName] = shuffleArray(generateRange(start, end)).slice(0, scaledParticipantsCount || randomInt(20, 30));
+        if ([PAIR, TEAM].includes(participantType)) {
+            const [start, end] = rankingRange || [];
+            doublesRankings[scaleName] = shuffleArray(generateRange(start, end)).slice(0, scaledParticipantsCount || randomInt(20, 30));
+        }
+    }
+    if (ratingType && ratingsParameters[ratingType]) {
+        const { ratingMax, ratingMin, ratingAttributes } = category;
+        const ratingParameters = {
+            ...ratingsParameters[ratingType],
+            ...(ratingAttributes || {}),
+        };
+        const { attributes = {}, decimalsCount, accessors, range, step } = ratingParameters;
+        const getAttributes = (attributes) => {
+            const generatedAttributes = {};
+            const attributeKeys = Object.keys(attributes || {});
+            for (const attribute of attributeKeys) {
+                const attributeValue = attributes[attribute];
+                if (typeof attributeValue === 'object' && attributeValue.generator) {
+                    const { range } = attributeValue;
+                    const [min, max] = range.slice().sort();
+                    generatedAttributes[attribute] = randomInt(min, max);
+                }
+                else {
+                    generatedAttributes[attribute] = attributeValue;
+                }
+            }
+            return generatedAttributes;
+        };
+        const inverted = range[0] > range[1];
+        const skew = inverted ? 2 : 0.7;
+        const [min, max] = range.slice().sort();
+        const generateRatings = () => {
+            const ratingsBucket = generateRange(0, 2000)
+                .map(() => skewedDistribution(min, max, skew, step, decimalsCount));
+            return ratingsBucket
+                .filter((rating) => (!ratingMax || rating <= ratingMax) && (!ratingMin || rating >= ratingMin))
+                .slice(0, scaledParticipantsCount || randomInt(20, 30))
+                .map((scaleValue) => {
+                return !accessors
+                    ? scaleValue
+                    : Object.assign({}, ...accessors.map((accessor) => ({ [accessor]: scaleValue })), getAttributes(attributes));
+            });
+        };
+        const generatedRatings = generateRatings();
+        singlesRatings[scaleName] = [...ratingsValues, ...generatedRatings];
+        if ([PAIR, TEAM].includes(participantType)) {
+            doublesRatings[scaleName] = [...ratingsValues, ...generatedRatings];
+        }
+    }
+    return { singlesRankings, doublesRankings, singlesRatings, doublesRatings };
+}
 
 function processTieFormat(params) {
     const { alternatesCount = 0, tieFormatName, drawSize } = params;
@@ -51053,6 +51130,25 @@ function scaledTeamAssignment({ clearExistingAssignments = true, individualParti
     return { ...SUCCESS, scaledParticipants };
 }
 
+function removeRatings(params) {
+    const paramsCheck = checkRequiredParameters(params, [
+        { [TOURNAMENT_RECORD]: true, [EVENT_TYPE]: true },
+        { ratingType: false, [VALIDATE]: (value) => ratingsParameters[value] },
+    ]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const dynamicScaleName = `${params.ratingType}.${DYNAMIC}`;
+    const ratingType = params.asDynamic ? dynamicScaleName : params.ratingType;
+    const itemType = [SCALE$1, RATING$1, params.eventType, ratingType].join('.');
+    const participants = params.tournamentRecord.participants ?? [];
+    for (const participant of participants) {
+        if (participant.timeItems) {
+            participant.timeItems = participant.timeItems.filter((timeItem) => timeItem.itemType !== itemType);
+        }
+    }
+    return { ...SUCCESS };
+}
+
 function removePenalty(params) {
     const { tournamentRecords } = params;
     if (typeof tournamentRecords !== 'object' || !Object.keys(tournamentRecords).length)
@@ -51419,6 +51515,7 @@ var mutate$5 = {
     removeParticipantIdsFromAllTeams: removeParticipantIdsFromAllTeams,
     removePenalty: removePenalty,
     removePersonRequests: removePersonRequests,
+    removeRatings: removeRatings,
     scaledTeamAssignment: scaledTeamAssignment,
     setParticipantScaleItem: setParticipantScaleItem,
     setParticipantScaleItems: setParticipantScaleItems
@@ -51464,6 +51561,7 @@ var index$8 = {
     removeParticipantIdsFromAllTeams: removeParticipantIdsFromAllTeams,
     removePenalty: removePenalty,
     removePersonRequests: removePersonRequests,
+    removeRatings: removeRatings,
     scaledTeamAssignment: scaledTeamAssignment,
     setParticipantScaleItem: setParticipantScaleItem,
     setParticipantScaleItems: setParticipantScaleItems,
@@ -55313,23 +55411,80 @@ function setTournamentStatus({ tournamentRecord, status }) {
     return { ...SUCCESS };
 }
 
-function addOnlineResource({ tournamentRecord, onlineResource, organisationId, participantId, personId, courtId, venueId, }) {
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    if (!isObject(onlineResource))
-        return { error: MISSING_VALUE };
-    if (intersection(Object.keys(onlineResource), ['resourceSubType', 'resourceType', 'identifier']).length !== 3)
-        return decorateResult({
-            result: { error: INVALID_OBJECT },
-            context: { onlineResource },
+function removeOnlineResource(params) {
+    const paramsCheck = checkRequiredParameters(params, [{ tournamentRecord: true, onlineResource: true }]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const { tournamentRecord, onlineResource, organisationId, participantId, personId, courtId, venueId } = params;
+    if (organisationId) {
+        if (tournamentRecord.parentOrganisation?.parentOrganisationId !== organisationId) {
+            return decorateResult({ result: { error: NOT_FOUND } });
+        }
+        removeResource({ element: tournamentRecord.parentOrganisation, onlineResource });
+    }
+    else if (participantId || personId) {
+        const participant = (tournamentRecord.participants ?? []).find((p) => (personId && p.person?.personId === personId) || p.participantId === participantId);
+        if (!participant) {
+            if (personId) {
+                return decorateResult({ result: { error: NOT_FOUND } });
+            }
+            else {
+                return decorateResult({ result: { error: PARTICIPANT_NOT_FOUND } });
+            }
+        }
+        if (personId) {
+            if (participant.person?.personId !== personId) {
+                return decorateResult({ result: { error: INVALID_PARTICIPANT } });
+            }
+            removeResource({ element: participant.person, onlineResource });
+        }
+        else {
+            removeResource({ element: participant, onlineResource });
+        }
+    }
+    else if (courtId) {
+        const court = (tournamentRecord.venues ?? [])
+            .filter((v) => !venueId || v.venueId === venueId)
+            .flatMap((v) => (v.courts ?? []).filter((c) => c.courtId === courtId))?.[0];
+        if (!court)
+            return decorateResult({ result: { error: COURT_NOT_FOUND } });
+        removeResource({ element: court, onlineResource });
+    }
+    else if (venueId) {
+        const venue = (tournamentRecord.venues ?? []).find((v) => v.venueId === venueId);
+        if (!venue)
+            return decorateResult({ result: { error: VENUE_NOT_FOUND } });
+        removeResource({ element: venue, onlineResource });
+    }
+    else {
+        removeResource({ element: tournamentRecord, onlineResource });
+        addNotice({
+            payload: {
+                onlineResources: tournamentRecord.onlineResources,
+                tournamentId: tournamentRecord.tournamentId,
+            },
+            topic: MODIFY_TOURNAMENT_DETAIL,
         });
+    }
+    return { ...SUCCESS };
+}
+function removeResource({ element, onlineResource }) {
+    const onlineResources = (element.onlineResources ?? []).filter((resource) => !(resource?.[RESOURCE_SUB_TYPE] === onlineResource[RESOURCE_SUB_TYPE] &&
+        resource?.[RESOURCE_TYPE] === onlineResource[RESOURCE_TYPE] &&
+        resource?.[IDENTIFIER] === onlineResource[IDENTIFIER]));
+    element.onlineResources = onlineResources;
+}
+
+function addOnlineResource(params) {
+    const paramsCheck = checkRequiredParameters(params, [{ tournamentRecord: true, onlineResource: true }]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const { tournamentRecord, onlineResource, organisationId, participantId, personId, courtId, venueId } = params;
     if (organisationId) {
         if (tournamentRecord.parentOrganisation?.parentOrganisationId !== organisationId) {
             return decorateResult({ result: { error: NOT_FOUND } });
         }
-        if (!tournamentRecord.parentOrganisation.onlineResources)
-            tournamentRecord.parentOrganisation.onlineResources = [];
-        tournamentRecord.parentOrganisation.onlineResources.push(onlineResource);
+        mergeResource({ element: tournamentRecord.parentOrganisation, onlineResource });
     }
     else if (participantId || personId) {
         const participant = (tournamentRecord.participants ?? []).find((p) => (personId && p.person?.personId === personId) || p.participantId === participantId);
@@ -55345,14 +55500,10 @@ function addOnlineResource({ tournamentRecord, onlineResource, organisationId, p
             if (participant.person?.personId !== personId) {
                 return decorateResult({ result: { error: INVALID_PARTICIPANT } });
             }
-            if (!participant.person.onlineResources)
-                participant.person.onlineResources = [];
-            participant.person.onlineResources.push(onlineResource);
+            mergeResource({ element: participant.person, onlineResource });
         }
         else {
-            if (!participant.onlineResources)
-                participant.onlineResources = [];
-            participant.onlineResources.push(onlineResource);
+            mergeResource({ element: participant, onlineResource });
         }
     }
     else if (courtId) {
@@ -55361,25 +55512,34 @@ function addOnlineResource({ tournamentRecord, onlineResource, organisationId, p
             .flatMap((v) => (v.courts ?? []).filter((c) => c.courtId === courtId))?.[0];
         if (!court)
             return decorateResult({ result: { error: COURT_NOT_FOUND } });
-        if (!court.onlineResources)
-            court.onlineResources = [];
-        court.onlineResources.push(onlineResource);
+        mergeResource({ element: court, onlineResource });
     }
     else if (venueId) {
         const venue = (tournamentRecord.venues ?? []).find((v) => v.venueId === venueId);
         if (!venue)
             return decorateResult({ result: { error: VENUE_NOT_FOUND } });
-        if (!venue.onlineResources)
-            venue.onlineResources = [];
-        venue.onlineResources.push(onlineResource);
+        mergeResource({ element: venue, onlineResource });
     }
     else {
-        if (!tournamentRecord.onlineResources)
-            tournamentRecord.onlineResources = [];
-        tournamentRecord.onlineResources.push(onlineResource);
+        mergeResource({ element: tournamentRecord, onlineResource });
+        addNotice({
+            payload: {
+                onlineResources: tournamentRecord.onlineResources,
+                tournamentId: tournamentRecord.tournamentId,
+            },
+            topic: MODIFY_TOURNAMENT_DETAIL,
+        });
     }
     return { ...SUCCESS };
 }
+function mergeResource({ element, onlineResource }) {
+    const onlineResources = (element.onlineResources ?? []).filter((resource) => resource?.[RESOURCE_SUB_TYPE] !== onlineResource[RESOURCE_SUB_TYPE] &&
+        resource?.[RESOURCE_TYPE] !== onlineResource[RESOURCE_TYPE] &&
+        resource?.[IDENTIFIER] !== onlineResource[IDENTIFIER]);
+    onlineResources.push(onlineResource);
+    element.onlineResources = onlineResources;
+    return { ...SUCCESS };
+}
 
 function setTournamentName({ tournamentRecord, promotionalName, tournamentName, formalName }) {
     if (!tournamentRecord)
@@ -55591,6 +55751,7 @@ var mutate$1 = {
     removeEventExtension: removeEventExtension,
     removeExtension: removeExtension,
     removeNotes: removeNotes,
+    removeOnlineResource: removeOnlineResource,
     removeParticipantExtension: removeParticipantExtension,
     removeTournamentExtension: removeTournamentExtension,
     setTournamentCategories: setTournamentCategories,
@@ -55634,6 +55795,7 @@ var index$3 = {
     removeEventExtension: removeEventExtension,
     removeExtension: removeExtension,
     removeNotes: removeNotes,
+    removeOnlineResource: removeOnlineResource,
     removeParticipantExtension: removeParticipantExtension,
     removeTournamentExtension: removeTournamentExtension,
     setTournamentCategories: setTournamentCategories,
@@ -57404,26 +57566,35 @@ const mocksEngine = (() => {
         governors.forEach((governor) => {
             Object.keys(governor).forEach((method) => {
                 engine[method] = (params) => {
-                    try {
+                    if (getDevContext()) {
                         const invocationResult = engineInvoke(governor[method], params);
                         if (!invocationResult?.error && params?.setState && invocationResult?.tournamentRecord) {
                             setState$1(invocationResult.tournamentRecord);
                         }
                         return invocationResult;
                     }
-                    catch (err) {
-                        let error;
-                        if (typeof err === 'string') {
-                            error = err.toUpperCase();
+                    else {
+                        try {
+                            const invocationResult = engineInvoke(governor[method], params);
+                            if (!invocationResult?.error && params?.setState && invocationResult?.tournamentRecord) {
+                                setState$1(invocationResult.tournamentRecord);
+                            }
+                            return invocationResult;
                         }
-                        else if (err instanceof Error) {
-                            error = err.message;
+                        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,
+                                error,
+                            });
                         }
-                        console.log('ERROR', {
-                            params: JSON.stringify(params),
-                            method,
-                            error,
-                        });
                     }
                 };
             });