tods-competition-factory 2.0.49 → 2.0.51

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function factoryVersion() {
-    return '2.0.49';
+    return '2.0.51';
 }
 
 function isFunction(obj) {
@@ -1783,6 +1783,27 @@ function decorateResult({ context, result, stack, info }) {
     return result ?? { success: 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 TOURNAMENT_RECORDS = 'tournamentRecords';
 const POLICY_DEFINITIONS = 'policyDefinitions';
 const TOURNAMENT_RECORD = 'tournamentRecord';
@@ -1798,6 +1819,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 +1847,9 @@ 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),
+};
 const errors = {
     [TOURNAMENT_RECORDS]: MISSING_TOURNAMENT_RECORDS,
     [TOURNAMENT_RECORD]: MISSING_TOURNAMENT_RECORD,
@@ -1836,6 +1861,7 @@ const errors = {
     [STRUCTURE_ID]: MISSING_STRUCTURE_ID,
     [MATCHUP_IDS]: MISSING_MATCHUP_IDS,
     [PARTICIPANT]: MISSING_PARTICIPANT,
+    [EVENT_TYPE]: INVALID_EVENT_TYPE,
     [STRUCTURES]: MISSING_STRUCTURES,
     [MATCHUP_ID]: MISSING_MATCHUP_ID,
     [STRUCTURE]: MISSING_STRUCTURE,
@@ -1923,7 +1949,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 +1975,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 +2717,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 +2735,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 +2767,7 @@ const extensionConstants = {
     PERSON_REQUESTS,
     POSITION_ACTIONS,
     RANKING_POINTS,
+    REGISTRATION: REGISTRATION$1,
     ROUND_TARGET,
     SCHEDULE_LIMITS,
     SCHEDULE_TIMING,
@@ -2772,9 +2781,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 +2795,7 @@ const internalExtensions = [
     SCHEDULING_PROFILE,
     SUB_ORDER,
     TALLY,
+    TIE_FORMAT_MODIFICATIONS,
 ];
 
 function linkTournaments({ tournamentRecords }) {
@@ -26492,9 +26504,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],
@@ -26505,6 +26522,7 @@ function addDynamicRatings({ tournamentRecord, modifiedScaleValues, removePriorV
         if (result.error)
             return result;
     }
+    return { ...SUCCESS };
 }
 
 function getParticipantScaleItem(params) {
@@ -26616,24 +26634,30 @@ const aggregateSets = (sets) => {
 };
 
 function generateDynamicRatings(params) {
-    const { updateParticipantRatings, removePriorValues = true, tournamentRecord, ratingType = ELO, considerGames, matchUpIds, asDynamic, } = params;
-    if (!tournamentRecord)
-        return { error: MISSING_TOURNAMENT_RECORD };
-    if (!Array.isArray(matchUpIds))
-        return { error: MISSING_MATCHUPS };
-    if (typeof ratingType !== 'string')
-        return { error: INVALID_VALUES, ratingType };
-    if (!ratingsParameters[ratingType])
-        return { error: INVALID_VALUES };
+    const paramsCheck = checkRequiredParameters(params, [
+        { [TOURNAMENT_RECORD]: true },
+        { matchUpIds: true, [OF_TYPE]: ARRAY, [ERROR]: MISSING_MATCHUP_IDS },
+        { ratingType: false, [VALIDATE]: (value) => ratingsParameters[value] },
+    ]);
+    if (paramsCheck.error)
+        return paramsCheck;
+    const { updateParticipantRatings, removePriorValues = true, tournamentRecord, ratingType = ELO, refreshDynamic, considerGames, drawDefinition, matchUpIds, asDynamic, } = 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;
@@ -26662,16 +26686,20 @@ function generateDynamicRatings(params) {
         const scaleItemMap = Object.assign({}, ...Object.values(sideParticipantIds)
             .flat()
             .map((participantId) => {
-            const { scaleItem: dynamicScaleItem } = getParticipantScaleItem({
-                scaleAttributes: dynamicScaleAttributes,
-                tournamentRecord,
-                participantId,
-            });
-            const { scaleItem } = getParticipantScaleItem({
+            const existingModifiedScaleValue = modifiedScaleValues[participantId];
+            const useDynamic = !refreshDynamic || existingModifiedScaleValue;
+            const dynamicScaleItem = useDynamic
+                ? getParticipantScaleItem({
+                    scaleAttributes: dynamicScaleAttributes,
+                    tournamentRecord,
+                    participantId,
+                }).scaleItem
+                : undefined;
+            const scaleItem = getParticipantScaleItem({
                 tournamentRecord,
                 scaleAttributes,
                 participantId,
-            });
+            }).scaleItem;
             const scaleValue = accessor ? { [accessor]: undefined } : undefined;
             return (participantId && {
                 [participantId]: dynamicScaleItem ??
@@ -27032,7 +27060,7 @@ 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, participantIds, drawDefinition, adHocRatings, salted = 0.5, roundNumber, structureId, matchUpIds, eventType, structure, scaleName, idPrefix, isMock, event, }) {
+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, }) {
     if (!drawDefinition)
         return { error: MISSING_DRAW_DEFINITION };
     if (!structure && !structureId)
@@ -27056,10 +27084,12 @@ 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,
+                refreshDynamic,
+                drawDefinition,
                 matchUpIds,
             });
             if (result.error)
@@ -32242,7 +32272,7 @@ function drawMatic(params) {
     const structureResult = getAdHocStructure(params);
     if (structureResult.error)
         return structureResult;
-    const adHocRatings = getAdHocRatings(params);
+    let adHocRatings = getAdHocRatings(params);
     const isMock = params.tournamentRecord?.isMock ?? params.isMock;
     const eventType = params.eventType ?? params.event?.eventType;
     const matchUps = [];
@@ -32263,6 +32293,8 @@ function drawMatic(params) {
         if (result.error)
             return result;
         const { matchUps: roundMatchUps, ...roundResult } = result;
+        if (roundResult.modifiedScaleValues)
+            adHocRatings = roundResult.modifiedScaleValues;
         roundResults.push({ ...roundResult, iteration, matchUpsCount: roundMatchUps?.length });
         roundNumber = (roundResult?.roundNumber ?? 1) + 1;
         if (roundMatchUps?.length) {
@@ -38119,17 +38151,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);
@@ -38175,7 +38209,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) {
@@ -38195,7 +38229,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 };
@@ -38232,6 +38266,7 @@ function publishEvent(params) {
     const eventData = notify || params.returnEventData
         ? getEventData({
             includePositionAssignments,
+            ...params.eventDataParams,
             usePublishState: true,
             tournamentRecord,
             policyDefinitions,
@@ -38414,6 +38449,7 @@ function deleteDrawDefinitions(params) {
     addDrawDeletionTelemetry({ appliedPolicies, event, deletedDrawsDetail, auditData });
     if (autoPublish && publishedDrawsDeleted) {
         const result = publishEvent({
+            ...params.eventDataParams,
             drawIdsToRemove: drawIds,
             policyDefinitions,
             tournamentRecord,
@@ -47550,7 +47586,7 @@ 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;
+    const { ratingsParameters: ratingsParameters$1 = ratingsParameters, valuesInstanceLimit, 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 &&
@@ -47577,57 +47613,28 @@ 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({ category, scaledParticipantsCount, ratingsParameters: ratingsParameters$1, participantType, rankingRange });
+        assignResult(result);
+    }
+    if (Array.isArray(categories)) {
+        categories.forEach((category) => {
+            const result = genRatings({
+                scaledParticipantsCount,
+                ratingsParameters: ratingsParameters$1,
+                participantType,
+                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) {
@@ -47752,9 +47759,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,
@@ -47769,8 +47777,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,
@@ -47785,6 +47793,12 @@ function generateParticipants(params) {
                 participant,
                 category,
             });
+        };
+        if (Array.isArray(categories)) {
+            categories.forEach((category) => processCategory(category));
+        }
+        else if (category) {
+            processCategory(category);
         }
         return participant;
     }
@@ -47799,6 +47813,62 @@ function addScaleItem({ scaleValue: itemValue, participant, eventType, scaleType
         participant.timeItems.push(timeItem);
     }
 }
+function genRatings(params) {
+    const { category, scaledParticipantsCount, ratingsParameters, participantType } = 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.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));
+        });
+        singlesRatings[scaleName] = generateRatings();
+        if ([PAIR, TEAM].includes(participantType)) {
+            doublesRatings[scaleName] = generateRatings();
+        }
+    }
+    return { singlesRankings, doublesRankings, singlesRatings, doublesRatings };
+}
 
 function processTieFormat(params) {
     const { alternatesCount = 0, tieFormatName, drawSize } = params;
@@ -51038,6 +51108,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)
@@ -51404,6 +51493,7 @@ var mutate$5 = {
     removeParticipantIdsFromAllTeams: removeParticipantIdsFromAllTeams,
     removePenalty: removePenalty,
     removePersonRequests: removePersonRequests,
+    removeRatings: removeRatings,
     scaledTeamAssignment: scaledTeamAssignment,
     setParticipantScaleItem: setParticipantScaleItem,
     setParticipantScaleItems: setParticipantScaleItems
@@ -51449,6 +51539,7 @@ var index$8 = {
     removeParticipantIdsFromAllTeams: removeParticipantIdsFromAllTeams,
     removePenalty: removePenalty,
     removePersonRequests: removePersonRequests,
+    removeRatings: removeRatings,
     scaledTeamAssignment: scaledTeamAssignment,
     setParticipantScaleItem: setParticipantScaleItem,
     setParticipantScaleItems: setParticipantScaleItems,
@@ -57389,26 +57480,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,
-                        });
                     }
                 };
             });