@mtes-mct/monitor-ui 24.33.0 → 24.34.0

package/cypress/index.js

@@ -1,1145 +0,0 @@
-// I have no idea why I have to add this dirty hack of setting an external variable
-// instead of using a cleaner FP `.filter()`
-// but real experience made me think it greatly improves results stability.
-function findElementByText(selector, text, { fallbackSelector, index = 0, inElement } = {}) {
-    const trimmedText = text.trim();
-    if (inElement) {
-        let foundElement;
-        let foundElementIndex = 0;
-        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-        Cypress.$(inElement).find(selector)// eslint-disable-next-line func-names
-        .each(function() {
-            if (!foundElement && Cypress.$(this).text().trim() === trimmedText) {
-                if (foundElementIndex < index) {
-                    foundElementIndex += 1;
-                    return;
-                }
-                foundElement = this;
-            }
-        });
-        if (!foundElement && fallbackSelector) {
-            cy.log(`⚠️ Using fallback selector: "${fallbackSelector}"`);
-            const foundElementByFallbackSelector = Cypress.$(inElement).find(fallbackSelector);
-            return foundElementByFallbackSelector;
-        }
-        return foundElement;
-    }
-    let foundElement;
-    let foundElementIndex = 0;
-    // eslint-disable-next-line func-names, @typescript-eslint/no-unused-expressions
-    Cypress.$(selector).each(function() {
-        if (!foundElement && Cypress.$(this).text().trim() === trimmedText) {
-            if (foundElementIndex < index) {
-                foundElementIndex += 1;
-                return;
-            }
-            foundElement = this;
-        }
-    });
-    if (!foundElement && fallbackSelector) {
-        // eslint-disable-next-line no-console
-        console.warn(`Using fallback selector: "${fallbackSelector}".`);
-        const foundElementByFallbackSelector = Cypress.$(fallbackSelector);
-        return foundElementByFallbackSelector;
-    }
-    return foundElement;
-}
-
-const RETRIES = 5;
-function findButton(label, preSelector, { index, prevSubjectElement }) {
-    const buttonElement = findElementByText(`${preSelector}button`, label, {
-        index,
-        inElement: prevSubjectElement
-    });
-    if (buttonElement) {
-        return buttonElement;
-    }
-    const buttonElementByAriaLabel = prevSubjectElement ? prevSubjectElement.querySelectorAll(`${preSelector}button[aria-label="${label}"]`)[index] : Cypress.$(`${preSelector}button[aria-label="${label}"]`).get(index);
-    if (buttonElementByAriaLabel) {
-        return buttonElementByAriaLabel;
-    }
-    const buttonElementByTitle = prevSubjectElement ? prevSubjectElement.querySelectorAll(`${preSelector}button[title="${label}"]`)[index] : Cypress.$(`${preSelector}button[title="${label}"]`).get(index);
-    if (buttonElementByTitle) {
-        return buttonElementByTitle;
-    }
-    const buttonRoleElement = findElementByText(`${preSelector}[role="button"]`, label, {
-        index,
-        inElement: prevSubjectElement
-    });
-    if (buttonRoleElement) {
-        return buttonRoleElement;
-    }
-    const buttonRoleElementByAriaLabel = prevSubjectElement ? prevSubjectElement.querySelectorAll(`${preSelector}[role="button"][aria-label="${label}"]`)[index] : Cypress.$(`${preSelector}[role="button"][aria-label="${label}"]`).get(index);
-    if (buttonRoleElementByAriaLabel) {
-        return buttonRoleElementByAriaLabel;
-    }
-    const buttonRoleElementByTitle = prevSubjectElement ? prevSubjectElement.querySelectorAll(`${preSelector}[role="button"][title="${label}"]`)[index] : Cypress.$(`${preSelector}[role="button"][title="${label}"]`).get(index);
-    if (buttonRoleElementByTitle) {
-        return buttonRoleElementByTitle;
-    }
-    const menuItemRoleElement = findElementByText(`${preSelector}[role="menuitem"]`, label, {
-        index,
-        inElement: prevSubjectElement
-    });
-    if (menuItemRoleElement) {
-        return menuItemRoleElement;
-    }
-    return undefined;
-}
-function clickButton(prevSubjectElements, label, { index = 0, withinSelector, withoutScroll = false } = {}, leftRetries = RETRIES) {
-    const prevSubjectElement = prevSubjectElements ? prevSubjectElements[0] : undefined;
-    if (prevSubjectElements && !prevSubjectElements[0]) {
-        throw new Error('`prevSubjectElements[0]` is undefined.');
-    }
-    const preSelector = withinSelector ? `${withinSelector} ` : '';
-    const maybeButton = findButton(label, preSelector, {
-        index,
-        prevSubjectElement
-    });
-    if (maybeButton) {
-        return (withoutScroll ? cy.wrap(maybeButton).forceClick() : cy.wrap(maybeButton).scrollIntoView().forceClick()).wait(250);
-    }
-    if (leftRetries > 0) {
-        return cy.wait(250).then(()=>{
-            cy.log(`Retrying (${RETRIES - leftRetries + 1} / ${RETRIES})...`);
-            return clickButton(prevSubjectElements, label, {
-                index,
-                withinSelector,
-                withoutScroll
-            }, leftRetries - 1);
-        });
-    }
-    throw new Error(`Unable to find button with label "${label}".`);
-}
-
-function clickLink(linkText) {
-    return cy.get('a').contains(linkText).click();
-}
-
-/**
- * @description
- * Useful to close modals.
- */ function clickOutside(xPosition = 0, yPosition = 0) {
-    cy.log(`Click outside at position: ${xPosition}, ${yPosition}`);
-    cy.get('body').click(xPosition, yPosition, {
-        force: true
-    });
-}
-
-const MAX_PARENT_INDEX = 100;
-function findElementParentBySelector(element, parentSelector, index = 0) {
-    let currentParentElement = element;
-    let lastFoundParentIndex = 0;
-    let parentIndex = -1;
-    while(parentIndex < MAX_PARENT_INDEX){
-        parentIndex += 1;
-        currentParentElement = currentParentElement.parentElement;
-        if (!currentParentElement) {
-            return undefined;
-        }
-        if (currentParentElement.matches(parentSelector)) {
-            if (lastFoundParentIndex === index) {
-                return currentParentElement;
-            }
-            lastFoundParentIndex += 1;
-        }
-    }
-    return undefined;
-}
-
-function checkCheckbox(fieldElement, value, _label, force) {
-    Cypress.log({
-        consoleProps: ()=>({
-                'Applied to': fieldElement,
-                Elements: 1
-            }),
-        name: 'checkCheckbox'
-    });
-    cy.wrap(fieldElement).scrollIntoView({
-        offset: {
-            left: 0,
-            top: -100
-        }
-    });
-    if (value) {
-        cy.wrap(fieldElement).find('input[type="checkbox"]').check({
-            force
-        }).wait(250);
-    } else {
-        cy.wrap(fieldElement).find('input[type="checkbox"]').uncheck({
-            force
-        }).wait(250);
-    }
-}
-
-function checkMultiCheckboxOptions(fieldsetElement, values, _label, force) {
-    Cypress.log({
-        consoleProps: ()=>({
-                'Applied to': fieldsetElement,
-                Elements: 1
-            }),
-        name: 'checkMultiCheckboxOptions'
-    });
-    cy.wrap(fieldsetElement).scrollIntoView({
-        offset: {
-            left: 0,
-            top: -100
-        }
-    });
-    cy.wrap(fieldsetElement).find('input[type="checkbox"]').uncheck({
-        force
-    }).wait(250);
-    // If `values` is undefined, we don't need to check anything
-    if (!values) {
-        return;
-    }
-    values.forEach((value)=>{
-        cy.wrap(fieldsetElement).contains('.rs-checkbox-label', value).closest('.rs-checkbox').find('input[type="checkbox"]').check({
-            force
-        });
-    });
-    cy.wait(250);
-}
-
-function checkMultiRadioOption(fieldsetElement, value, _label, force) {
-    Cypress.log({
-        consoleProps: ()=>({
-                'Applied to': fieldsetElement,
-                Elements: 1
-            }),
-        name: 'checkMultiRadioOption'
-    });
-    cy.wrap(fieldsetElement).scrollIntoView({
-        offset: {
-            left: 0,
-            top: -100
-        }
-    }).find('label').contains(value).click({
-        force
-    }).wait(250);
-}
-
-const DEFAULT_OPTIONS = {
-    delay: 10,
-    force: true,
-    index: 0,
-    retries: 5
-};
-
-function throwError(message) {
-    throw new Error(`[monitor-ui > Cypress] ${message}`);
-}
-
-function fillDatePicker(fieldsetElement, dateOrDateWithTimeTuple, _label, force, delay) {
-    Cypress.log({
-        consoleProps: ()=>({
-                'Applied to': fieldsetElement,
-                Elements: 1
-            }),
-        name: 'fillDatePicker'
-    });
-    const inputElements = fieldsetElement.querySelectorAll('input');
-    if (inputElements.length !== 4 && inputElements.length !== 6) {
-        throwError(`Expected to find 4 or 6 inputs within in DatePicker but found ${inputElements.length}.`);
-    }
-    const hasTimeInputs = inputElements.length === 6;
-    // Empty the inputs if `dateOrDateWithTimeTuple` is undefined
-    if (!dateOrDateWithTimeTuple) {
-        // -------------------------------------------------------------------------
-        // Date without time
-        cy.wrap(fieldsetElement).find('[aria-label="Jour"]').clear({
-            force
-        });
-        cy.wrap(fieldsetElement).find('[aria-label="Mois"]').clear({
-            force
-        });
-        cy.wrap(fieldsetElement).find('[aria-label="Année"]').clear({
-            force
-        });
-        if (hasTimeInputs) {
-            cy.wrap(fieldsetElement).find('[aria-label="Heure"]').clear({
-                force
-            });
-            cy.wrap(fieldsetElement).find('[aria-label="Minute"]').clear({
-                force
-            });
-        }
-    } else {
-        const [year, month, day] = dateOrDateWithTimeTuple;
-        cy.wrap(fieldsetElement).find('[aria-label="Jour"]').type(String(day).padStart(2, '0'), {
-            delay,
-            force
-        });
-        cy.wrap(fieldsetElement).find('[aria-label="Mois"]').type(String(month).padStart(2, '0'), {
-            delay,
-            force
-        });
-        cy.wrap(fieldsetElement).find('[aria-label="Année"]').type(String(year), {
-            delay,
-            force
-        });
-        if (hasTimeInputs) {
-            const [hour, minute] = dateOrDateWithTimeTuple.slice(3);
-            cy.wrap(fieldsetElement).find('[aria-label="Heure"]').type(String(hour).padStart(2, '0'), {
-                delay,
-                force
-            });
-            cy.wrap(fieldsetElement).find('[aria-label="Minute"]').type(String(minute).padStart(2, '0'), {
-                delay,
-                force
-            });
-        }
-    }
-    cy.wait(250);
-    // Close the calendar & ranged time picker popup by pressing the escape key
-    cy.get('body').type('{esc}', {
-        delay,
-        force
-    });
-    // TODO Create a util to handle the `fieldsetElement` re-creation cases.
-    // We to use a `wait` as a temporary fix to handle `fieldsetElement` re-creation cases.
-    cy.wait(250);
-// cy.wrap(fieldsetElement).find('.Field-DatePicker__CalendarPicker').should('not.be.visible')
-// cy.wrap(fieldsetElement).find('.Field-DateRangePicker__RangedTimePicker').should('not.exist')
-}
-
-function fillDateRangePicker(fieldsetElement, dateOrDateWithTimeTupleRange, _label, force, delay) {
-    Cypress.log({
-        consoleProps: ()=>({
-                'Applied to': fieldsetElement,
-                Elements: 1
-            }),
-        name: 'fillDateRangePicker'
-    });
-    const inputElements = fieldsetElement.querySelectorAll('input');
-    if (inputElements.length !== 7 && inputElements.length !== 11) {
-        throwError(`Expected to find 7 or 11 inputs within in DatePicker but found ${inputElements.length}.`);
-    }
-    const hasTimeInput = inputElements.length !== 7;
-    // Empty the inputs if `dateOrDateWithTimeTupleRange` is undefined
-    if (!dateOrDateWithTimeTupleRange) {
-        cy.wrap(fieldsetElement).find('[aria-label="Jour de début"]').clear({
-            force
-        });
-        cy.wrap(fieldsetElement).find('[aria-label="Mois de début"]').clear({
-            force
-        });
-        cy.wrap(fieldsetElement).find('[aria-label="Année de début"]').clear({
-            force
-        });
-        if (hasTimeInput) {
-            cy.wrap(fieldsetElement).find('[aria-label="Heure de début"]').clear({
-                force
-            });
-            cy.wrap(fieldsetElement).find('[aria-label="Minute de début"]').clear({
-                force
-            });
-        }
-        cy.wrap(fieldsetElement).find('[aria-label="Jour de fin"]').clear({
-            force
-        });
-        cy.wrap(fieldsetElement).find('[aria-label="Mois de fin"]').clear({
-            force
-        });
-        cy.wrap(fieldsetElement).find('[aria-label="Année de fin"]').clear({
-            force
-        });
-        if (hasTimeInput) {
-            cy.wrap(fieldsetElement).find('[aria-label="Heure de fin"]').clear({
-                force
-            });
-            cy.wrap(fieldsetElement).find('[aria-label="Minute de fin"]').clear({
-                force
-            });
-        }
-    } else {
-        const [startDateOrDateWithTimeTuple, endDateOrDateWithTimeTuple] = dateOrDateWithTimeTupleRange;
-        const [startYear, startMonth, startDay, startHour, startMinute] = startDateOrDateWithTimeTuple;
-        const [endYear, endMonth, endDay, endHour, endMinute] = endDateOrDateWithTimeTuple;
-        cy.wrap(fieldsetElement).find('[aria-label="Jour de début"]').type(String(startDay).padStart(2, '0'), {
-            delay,
-            force
-        });
-        cy.wrap(fieldsetElement).find('[aria-label="Mois de début"]').type(String(startMonth).padStart(2, '0'), {
-            delay,
-            force
-        });
-        cy.wrap(fieldsetElement).find('[aria-label="Année de début"]').type(String(startYear), {
-            force
-        });
-        if (hasTimeInput) {
-            cy.wrap(fieldsetElement).find('[aria-label="Heure de début"]').type(String(startHour).padStart(2, '0'), {
-                delay,
-                force
-            });
-            cy.wrap(fieldsetElement).find('[aria-label="Minute de début"]').type(String(startMinute).padStart(2, '0'), {
-                force
-            });
-        }
-        cy.wrap(fieldsetElement).find('[aria-label="Jour de fin"]').type(String(endDay).padStart(2, '0'), {
-            delay,
-            force
-        });
-        cy.wrap(fieldsetElement).find('[aria-label="Mois de fin"]').type(String(endMonth).padStart(2, '0'), {
-            delay,
-            force
-        });
-        cy.wrap(fieldsetElement).find('[aria-label="Année de fin"]').type(String(endYear), {
-            force
-        });
-        if (hasTimeInput) {
-            cy.wrap(fieldsetElement).find('[aria-label="Heure de fin"]').type(String(endHour).padStart(2, '0'), {
-                delay,
-                force
-            });
-            cy.wrap(fieldsetElement).find('[aria-label="Minute de fin"]').type(String(endMinute).padStart(2, '0'), {
-                delay,
-                force
-            });
-        }
-    }
-    cy.wait(250);
-    // Close the range calendar & ranged time picker popup by pressing the escape key
-    cy.get('body').type('{esc}', {
-        delay,
-        force
-    });
-    // TODO Create a util to handle the `fieldsetElement` re-creation cases.
-    // We to use a `wait` as a temporary fix to handle `fieldsetElement` re-creation cases.
-    cy.wait(250);
-// cy.wrap(fieldsetElement).find('.Field-DateRangePicker__RangeCalendarPicker').should('not.be.visible')
-// cy.wrap(fieldsetElement).find('.Field-DateRangePicker__RangedTimePicker').should('not.exist')
-}
-
-function fillNumberInput(fieldElement, value, _label, force, delay) {
-    Cypress.log({
-        consoleProps: ()=>({
-                'Applied to': fieldElement,
-                Elements: 1
-            }),
-        name: 'fillNumberInput'
-    });
-    cy.wrap(fieldElement).scrollIntoView({
-        offset: {
-            left: 0,
-            top: -100
-        }
-    });
-    cy.wrap(fieldElement).find('input[type="number"]').clear({
-        force
-    }).wait(250);
-    // If `value` is undefined, we don't need to input anything
-    if (!value) {
-        return;
-    }
-    cy.wrap(fieldElement).find('input[type="number"]').type(String(value), {
-        delay,
-        force
-    }).wait(250);
-}
-
-function fillTextarea(fieldElement, value, _label, force, delay) {
-    Cypress.log({
-        consoleProps: ()=>({
-                'Applied to': fieldElement,
-                Elements: 1
-            }),
-        name: 'fillTextarea'
-    });
-    cy.wrap(fieldElement).scrollIntoView({
-        offset: {
-            left: 0,
-            top: -100
-        }
-    });
-    cy.wrap(fieldElement).find('textarea').clear({
-        force
-    }).wait(250);
-    // If `value` is undefined, we don't need to input anything
-    if (!value) {
-        return;
-    }
-    cy.wrap(fieldElement).find('textarea').type(value, {
-        delay,
-        force
-    }).wait(250);
-}
-
-function fillTextInput(fieldElement, value, _label, force, delay) {
-    Cypress.log({
-        consoleProps: ()=>({
-                'Applied to': fieldElement,
-                Elements: 1
-            }),
-        name: 'fillTextInput'
-    });
-    cy.wrap(fieldElement).scrollIntoView({
-        offset: {
-            left: 0,
-            top: -100
-        }
-    });
-    cy.wrap(fieldElement).find('input').clear({
-        force
-    }).wait(250);
-    // If `value` is undefined, we don't need to input anything
-    if (!value) {
-        return;
-    }
-    cy.wrap(fieldElement).find('input').type(value, {
-        delay,
-        force
-    }).wait(250);
-}
-
-function pickCheckPickerOptions(fieldElement, values, label, force, delay, role = 'option') {
-    Cypress.log({
-        consoleProps: ()=>({
-                'Applied to': fieldElement,
-                Elements: 1
-            }),
-        name: 'pickCheckPickerOptions'
-    });
-    cy.wrap(fieldElement).scrollIntoView({
-        offset: {
-            left: 0,
-            top: -100
-        }
-    });
-    // Clear the field if there is a clear button
-    const maybeClearButton = fieldElement.querySelector('.rs-stack > .rs-stack-item > .rs-picker-clean');
-    if (maybeClearButton) {
-        cy.wrap(fieldElement).find('.rs-stack > .rs-stack-item > .rs-picker-clean').click({
-            force
-        }).wait(250);
-    }
-    // If `values` is undefined, we don't need to select anything
-    if (!values) {
-        return;
-    }
-    cy.wrap(fieldElement).find('.rs-picker-toggle').click({
-        force
-    });
-    // Wait for the picker to open
-    cy.wrap(fieldElement).find('.rs-picker-popup').then(([rsuitePickerPopupElement])=>{
-        if (!rsuitePickerPopupElement) {
-            throwError(`Could not find '.rs-picker-popup' in in field with label "${label}". Did the picker open?`);
-        }
-        // Search for the value if there is a search input
-        const maybeSearchInput = rsuitePickerPopupElement.querySelector('input[role="searchbox"]');
-        values.forEach((value)=>{
-            if (maybeSearchInput) {
-                cy.wrap(rsuitePickerPopupElement).find('input[role="searchbox"]').clear().type(value, {
-                    delay,
-                    force
-                }).wait(250);
-            }
-            cy.wrap(rsuitePickerPopupElement).find(`[role="${role}"]`).contains(value).first().scrollIntoView().click({
-                force
-            });
-        });
-        // Close the picker popup by pressing the escape key
-        cy.get('body').type('{esc}', {
-            delay,
-            force
-        });
-        // TODO Create a util to handle the `fieldElement` re-creation cases.
-        // We to use a `wait` as a temporary fix to handle `fieldElement` re-creation cases.
-        cy.wait(250);
-    // cy.wrap(fieldElement).find('.rs-picker-popup').should('not.exist')
-    });
-}
-
-function pickMultiCascaderOptions(fieldElement, values, label, force, delay) {
-    Cypress.log({
-        consoleProps: ()=>({
-                'Applied to': fieldElement,
-                Elements: 1
-            }),
-        name: 'pickMultiCascaderOptions'
-    });
-    cy.wrap(fieldElement).scrollIntoView({
-        offset: {
-            left: 0,
-            top: -100
-        }
-    });
-    // Clear the field if there is a clear button
-    const maybeClearButton = fieldElement.querySelector('.rs-stack > .rs-stack-item > .rs-picker-clean');
-    if (maybeClearButton) {
-        cy.wrap(fieldElement).find('.rs-stack > .rs-stack-item > .rs-picker-clean').click({
-            force
-        }).wait(250);
-    }
-    // If `values` is undefined, we don't need to select anything
-    if (!values) {
-        return;
-    }
-    cy.wrap(fieldElement).find('.rs-picker-toggle').click({
-        force
-    });
-    // Wait for the picker to open
-    cy.wrap(fieldElement).find('.rs-picker-popup').then(([rsuitePickerPopupElement])=>{
-        if (!rsuitePickerPopupElement) {
-            throwError(`Could not find '.rs-picker-popup' in in field with label "${label}". Did the picker open?`);
-        }
-        // Search for the value if there is a search input
-        const maybeSearchInput = rsuitePickerPopupElement.querySelector('input[role="searchbox"]');
-        if (!maybeSearchInput) {
-            throwError(throwError(`\`cy.fill()\` can't handle the MultiCascader with \`<label>\` "${label}" because it's not \`searchable\`.`));
-        }
-        values.forEach((value)=>{
-            cy.wrap(rsuitePickerPopupElement).find('input[role="searchbox"]').clear().type(value, {
-                delay,
-                force
-            }).wait(250);
-            cy.wrap(rsuitePickerPopupElement).find('[role="treeitem"]').contains(value).first().scrollIntoView().click({
-                force
-            });
-        });
-        // Close the picker popup by pressing the escape key
-        cy.get('body').type('{esc}', {
-            delay,
-            force
-        });
-        // TODO Create a util to handle the `fieldElement` re-creation cases.
-        // We to use a `wait` as a temporary fix to handle `fieldElement` re-creation cases.
-        cy.wait(250);
-    // cy.wrap(fieldElement).find('.rs-picker-popup').should('not.exist')
-    });
-}
-
-function pickMultiSelectOptions(fieldElement, values, label, force, delay) {
-    Cypress.log({
-        consoleProps: ()=>({
-                'Applied to': fieldElement,
-                Elements: 1
-            }),
-        name: 'pickMultiSelectOptions'
-    });
-    cy.wrap(fieldElement).scrollIntoView({
-        offset: {
-            left: 0,
-            top: -100
-        }
-    });
-    // Clear the field if there is a clear button
-    const maybeClearButton = fieldElement.querySelector('.rs-stack > .rs-stack-item > .rs-picker-clean');
-    if (maybeClearButton) {
-        cy.wrap(fieldElement).find('.rs-stack > .rs-stack-item > .rs-picker-clean').click({
-            force
-        }).wait(250);
-    }
-    // If `values` is undefined, we don't need to select anything
-    if (!values) {
-        return;
-    }
-    cy.wrap(fieldElement).find('.rs-picker-toggle').click({
-        force
-    });
-    // Wait for the picker to open
-    cy.wrap(fieldElement).get('.rs-picker-popup').then(([rsuitePickerPopupElement])=>{
-        if (!rsuitePickerPopupElement) {
-            throwError(`Could not find '.rs-picker-popup' in in field with label "${label}". Did the picker open?`);
-        }
-        values.forEach((value)=>{
-            // Search for the value if there is a search input
-            const maybeSearchInput = fieldElement.querySelector('.rs-picker-search-input > input');
-            if (maybeSearchInput) {
-                cy.wrap(fieldElement).find('.rs-picker-search-input > input').type(value, {
-                    delay,
-                    force
-                }).wait(250);
-            }
-            cy.wrap(rsuitePickerPopupElement).find('[role="option"]').contains(value).first().scrollIntoView().click({
-                force
-            });
-        });
-        // Close the picker popup by pressing the escape key
-        cy.get('body').type('{esc}', {
-            delay,
-            force
-        });
-        // TODO Create a util to handle the `fieldElement` re-creation cases.
-        // We to use a `wait` as a temporary fix to handle `fieldElement` re-creation cases.
-        cy.wait(250);
-    // cy.wrap(fieldElement).find('.rs-picker-popup').should('not.exist')
-    });
-}
-
-function pickSearchOption(fieldElement, value, _label, force, delay) {
-    Cypress.log({
-        consoleProps: ()=>({
-                'Applied to': fieldElement,
-                Elements: 1
-            }),
-        name: 'pickSearchOption'
-    });
-    cy.wrap(fieldElement).scrollIntoView({
-        offset: {
-            left: 0,
-            top: -100
-        }
-    });
-    // Clear the field if there is a clear button
-    const maybeClearButton = fieldElement.querySelector('.Field-Search__ClearButton');
-    if (maybeClearButton) {
-        cy.wrap(fieldElement).find('.Field-Search__ClearButton').click({
-            force
-        }).wait(250);
-    }
-    // If the value is undefined, we don't need to select anything
-    if (!value) {
-        return;
-    }
-    // Search for the value
-    cy.wrap(fieldElement).find('input[role="combobox"]').type(value, {
-        delay,
-        force
-    });
-    // Wait for the picker to open
-    cy.wrap(fieldElement).get('.rs-picker-popup').then(([rsuitePickerPopupElement])=>{
-        // Select the first picker option
-        cy.wrap(rsuitePickerPopupElement).find('[role="option"]').first().scrollIntoView().click({
-            force
-        }).wait(250);
-    });
-}
-
-function pickSelectOption(fieldElement, value, label, force, delay) {
-    Cypress.log({
-        consoleProps: ()=>({
-                'Applied to': fieldElement,
-                Elements: 1
-            }),
-        name: 'pickSelectOption'
-    });
-    cy.wrap(fieldElement).scrollIntoView({
-        offset: {
-            left: 0,
-            top: -100
-        }
-    });
-    // Clear the field if there is a clear button
-    const maybeClearButton = fieldElement.querySelector('.rs-stack > .rs-stack-item > .rs-picker-clean');
-    if (maybeClearButton) {
-        cy.wrap(fieldElement).find('.rs-stack > .rs-stack-item > .rs-picker-clean').click({
-            force
-        }).wait(250);
-    }
-    // If the value is undefined, we don't need to select anything
-    if (!value) {
-        return;
-    }
-    // Open the picker
-    cy.wrap(fieldElement).find('.rs-stack > .rs-stack-item > .rs-picker-caret-icon').click({
-        force
-    }).wait(250);
-    // Wait for the picker to open
-    cy.wrap(fieldElement).get('.rs-picker-popup').then(([rsuitePickerPopupElement])=>{
-        if (!rsuitePickerPopupElement) {
-            throwError(`Could not find '.rs-picker-popup' in in field with label "${label}". Did the picker open?`);
-        }
-        // Search for the value if there is a search input
-        const maybeSearchInput = rsuitePickerPopupElement.querySelector('input[role="searchbox"]');
-        if (maybeSearchInput) {
-            cy.wrap(rsuitePickerPopupElement).find('input[role="searchbox"]').type(value, {
-                delay,
-                force
-            }).wait(250);
-        }
-        cy.wrap(rsuitePickerPopupElement).find('[role="option"]').contains(value).scrollIntoView().click({
-            force
-        }).wait(250);
-    });
-}
-
-const throwAssertionError = (expectedType, component)=>throwError(`\`value\` should be of type \`${expectedType}\` in \`cy.fill(label, value)\` when used on a <${component} />.`);
-function assertBooleanOrUndefined(value, component) {
-    if (value === undefined || typeof value === 'boolean') {
-        return;
-    }
-    throwAssertionError('boolean | undefined', component);
-}
-function assertDateTupleOrDateWithTimeTupleOrUndefined(value, component) {
-    if (value === undefined) {
-        return;
-    }
-    if (Array.isArray(value) && (value.length === 3 || value.length === 5) && value.every((valueItem)=>typeof valueItem === 'number')) {
-        return;
-    }
-    throwAssertionError('DateTuple | DateWithTimeTuple | undefined', component);
-}
-function assertDateRangeTupleOrDateWithTimeRangeTupleOrUndefined(value, component) {
-    if (value === undefined) {
-        return;
-    }
-    if (Array.isArray(value) && value.length === 2 && (Array.isArray(value[0]) && value[0].length === 3 && value[1].length === 3 || Array.isArray(value[0]) && value[0].length === 5 && value[1].length === 5) && value.every((valueItem)=>Array.isArray(valueItem) && valueItem.every((valueItemItem)=>typeof valueItemItem === 'number'))) {
-        return;
-    }
-    throwAssertionError('DateRangeTuple | DateWithTimeRangeTuple | undefined', component);
-}
-function assertNumberOrUndefined(value, component) {
-    if (value === undefined || typeof value === 'number') {
-        return;
-    }
-    throwAssertionError('number | undefined', component);
-}
-function assertString(value, component) {
-    if (typeof value === 'string') {
-        return;
-    }
-    throwAssertionError('string', component);
-}
-function assertStringOrUndefined(value, component) {
-    if (value === undefined || typeof value === 'string') {
-        return;
-    }
-    throwAssertionError('string | undefined', component);
-}
-function assertStringArrayOrUndefined(value, component) {
-    if (value === undefined) {
-        return;
-    }
-    if (Array.isArray(value) && value.every((valueItem)=>typeof valueItem === 'string')) {
-        return;
-    }
-    throwAssertionError('string[] | undefined', component);
-}
-
-let TOTAL_RETRIES;
-function fill(label, value, options = {}) {
-    const controlledOptions = {
-        ...DEFAULT_OPTIONS,
-        ...options
-    };
-    if (!TOTAL_RETRIES) {
-        TOTAL_RETRIES = controlledOptions.retries;
-    }
-    Cypress.log({
-        consoleProps: ()=>({
-                'Left Retries': controlledOptions.retries
-            }),
-        message: `Filling field with label/legend "${label}" with value "${JSON.stringify(value)}".`,
-        name: 'fill'
-    });
-    try {
-        // =========================================================================
-        // If it's a field labelled by a `<label />` element
-        const labelElement = findElementByText('label', label, {
-            index: controlledOptions.index
-        });
-        if (labelElement) {
-            const fieldElement = findElementParentBySelector(labelElement, '.Element-Field');
-            if (!fieldElement) {
-                throwError(`Could not find '.Element-Field' in field with label "${label}" at index "${controlledOptions.index}".`);
-            }
-            switch(true){
-                // ---------------------------------------------------------------------
-                // Checkbox
-                case fieldElement.classList.contains('Field-Checkbox'):
-                    assertBooleanOrUndefined(value, 'Checkbox');
-                    checkCheckbox(fieldElement, value, label, controlledOptions.force);
-                    return;
-                // ---------------------------------------------------------------------
-                // CheckPicker
-                case fieldElement.classList.contains('Field-CheckPicker'):
-                    assertStringArrayOrUndefined(value, 'CheckPicker');
-                    pickCheckPickerOptions(fieldElement, value, label, controlledOptions.force, controlledOptions.delay);
-                    return;
-                // ---------------------------------------------------------------------
-                // CheckTreePicker
-                case fieldElement.classList.contains('Field-CheckTreePicker'):
-                    assertStringArrayOrUndefined(value, 'CheckTreePicker');
-                    pickCheckPickerOptions(fieldElement, value, label, controlledOptions.force, controlledOptions.delay, 'treeitem');
-                    return;
-                // ---------------------------------------------------------------------
-                // MultiCascader
-                case fieldElement.classList.contains('Field-MultiCascader'):
-                    assertStringArrayOrUndefined(value, 'MultiCascader');
-                    pickMultiCascaderOptions(fieldElement, value, label, controlledOptions.force, controlledOptions.delay);
-                    return;
-                // ---------------------------------------------------------------------
-                // MultiSelect
-                case fieldElement.classList.contains('Field-MultiSelect'):
-                    assertStringArrayOrUndefined(value, 'MultiSelect');
-                    pickMultiSelectOptions(fieldElement, value, label, controlledOptions.force, controlledOptions.delay);
-                    return;
-                // ---------------------------------------------------------------------
-                // Search
-                case fieldElement.classList.contains('Field-Search'):
-                    assertStringOrUndefined(value, 'Search');
-                    pickSearchOption(fieldElement, value, label, controlledOptions.force, controlledOptions.delay);
-                    return;
-                // ---------------------------------------------------------------------
-                // Select
-                case fieldElement.classList.contains('Field-Select'):
-                    assertStringOrUndefined(value, 'Select');
-                    pickSelectOption(fieldElement, value, label, controlledOptions.force, controlledOptions.delay);
-                    return;
-                // ---------------------------------------------------------------------
-                // NumberInput
-                case fieldElement.classList.contains('Field-NumberInput'):
-                    assertNumberOrUndefined(value, 'TextInput');
-                    fillNumberInput(fieldElement, value, label, controlledOptions.force, controlledOptions.delay);
-                    return;
-                // ---------------------------------------------------------------------
-                // Textarea
-                case fieldElement.classList.contains('Field-Textarea'):
-                    assertStringOrUndefined(value, 'Textarea');
-                    fillTextarea(fieldElement, value, label, controlledOptions.force, controlledOptions.delay);
-                    return;
-                // ---------------------------------------------------------------------
-                //  TextInput
-                case fieldElement.classList.contains('Field-TextInput'):
-                    assertStringOrUndefined(value, 'TextInput');
-                    fillTextInput(fieldElement, value, label, controlledOptions.force, controlledOptions.delay);
-                    return;
-                // ---------------------------------------------------------------------
-                //  PhoneInput
-                case fieldElement.classList.contains('Field-PhoneInput'):
-                    assertStringOrUndefined(value, 'PhoneInput');
-                    fillTextInput(fieldElement, value, label, controlledOptions.force, controlledOptions.delay);
-                    return;
-                // ---------------------------------------------------------------------
-                //  LinkInput
-                case fieldElement.classList.contains('Field-LinkInput'):
-                    assertStringOrUndefined(value, 'LinkInput');
-                    fillTextInput(fieldElement, value, label, controlledOptions.force, controlledOptions.delay);
-                    return;
-                default:
-                    throwError(`\`cy.fill()\` can't handle field with \`<label>\` "${label}".`);
-            }
-        }
-        // =========================================================================
-        // If it's a field labelled by a `<legend />` element
-        const legendElement = findElementByText('legend', label, {
-            index: controlledOptions.index
-        });
-        if (legendElement) {
-            const fieldsetElement = findElementParentBySelector(legendElement, '.Element-Fieldset');
-            if (!fieldsetElement) {
-                throwError(`Could not find '.Element-Fieldset' in field with \`<legend />\` "${label}" at index "${controlledOptions.index}".`);
-            }
-            switch(true){
-                // ---------------------------------------------------------------------
-                // DatePicker
-                case fieldsetElement.classList.contains('Field-DatePicker'):
-                    assertDateTupleOrDateWithTimeTupleOrUndefined(value, 'DatePicker');
-                    fillDatePicker(fieldsetElement, value, label, controlledOptions.force, controlledOptions.delay);
-                    return;
-                // ---------------------------------------------------------------------
-                // DateRangePicker
-                case fieldsetElement.classList.contains('Field-DateRangePicker'):
-                    assertDateRangeTupleOrDateWithTimeRangeTupleOrUndefined(value, 'DateRangePicker');
-                    fillDateRangePicker(fieldsetElement, value, label, controlledOptions.force, controlledOptions.delay);
-                    return;
-                // ---------------------------------------------------------------------
-                // MultiCheckbox
-                case fieldsetElement.classList.contains('Field-MultiCheckbox'):
-                    assertStringArrayOrUndefined(value, 'MultiCheckbox');
-                    checkMultiCheckboxOptions(fieldsetElement, value, label, controlledOptions.force);
-                    return;
-                // ---------------------------------------------------------------------
-                // MultiRadio
-                case fieldsetElement.classList.contains('Field-MultiRadio'):
-                    assertString(value, 'MultiRadio');
-                    checkMultiRadioOption(fieldsetElement, value, label, controlledOptions.force);
-                    return;
-                default:
-                    throwError(`\`cy.fill()\` can't handle the input element in field with \`<legend>\` "${label}".`);
-            }
-        }
-        throwError(`Could not find a field labelled by a \`<label />\` or \`<legend />\` "${label}".`);
-    } catch (err) {
-        if (controlledOptions.retries > 0) {
-            cy.wait(250).then(()=>{
-                cy.log(`[monitor-ui > Cypress] Retrying (${TOTAL_RETRIES - controlledOptions.retries + 1} / ${TOTAL_RETRIES})...`);
-                fill(label, value, {
-                    ...controlledOptions,
-                    retries: controlledOptions.retries - 1
-                });
-            });
-            return;
-        }
-        const normalizedError = err instanceof Error ? err : new Error(String(err));
-        Cypress.log({
-            consoleProps: ()=>({
-                    err,
-                    label,
-                    value
-                }),
-            displayName: 'ERROR',
-            message: String(normalizedError.message),
-            name: 'fill'
-        }).error(normalizedError);
-        throwError([
-            `Could not find or fill field with label or legend "${label}" at index "${controlledOptions.index}" after ${TOTAL_RETRIES} attempts.`,
-            `This error was thrown: “${normalizedError.message}”`,
-            `Please check the Cypress "- ERROR" log above for more details.`
-        ].join('\n'));
-    }
-}
-
-function forceCheck(subject, options = {}) {
-    Cypress.log({
-        consoleProps: ()=>({
-                'Applied to': subject,
-                Elements: 1
-            }),
-        name: 'forceCheck'
-    });
-    if (!subject) {
-        throw new Error(`Could not find subject.`);
-    }
-    const wrappedSubject = cy.wrap(subject);
-    return wrappedSubject.check({
-        ...options,
-        force: true
-    });
-}
-
-function forceClear(subject, options = {}) {
-    Cypress.log({
-        consoleProps: ()=>({
-                'Applied to': subject,
-                Elements: 1
-            }),
-        name: 'forceClear'
-    });
-    if (!subject) {
-        throw new Error(`Could not find subject.`);
-    }
-    const wrappedSubject = cy.wrap(subject);
-    return wrappedSubject.clear({
-        ...options,
-        force: true
-    });
-}
-
-function forceClick(subject, options = {}) {
-    Cypress.log({
-        consoleProps: ()=>({
-                'Applied to': subject,
-                Elements: 1
-            }),
-        name: 'forceClick'
-    });
-    if (!subject) {
-        throw new Error(`Could not find subject.`);
-    }
-    const wrappedSubject = cy.wrap(subject);
-    return wrappedSubject.click({
-        ...options,
-        force: true
-    });
-}
-
-function forceType(subject, text, options = {}) {
-    Cypress.log({
-        consoleProps: ()=>({
-                'Applied to': subject,
-                Elements: 1
-            }),
-        name: 'forceType'
-    });
-    if (!subject) {
-        throw new Error(`Could not find subject.`);
-    }
-    const wrappedSubject = cy.wrap(subject);
-    return wrappedSubject.type(text, {
-        ...options,
-        force: true
-    });
-}
-
-function forceUncheck(subject, options = {}) {
-    Cypress.log({
-        consoleProps: ()=>({
-                'Applied to': subject,
-                Elements: 1
-            }),
-        name: 'forceUncheck'
-    });
-    if (!subject) {
-        throw new Error(`Could not find subject.`);
-    }
-    const wrappedSubject = cy.wrap(subject);
-    return wrappedSubject.uncheck({
-        ...options,
-        force: true
-    });
-}
-
-function getDataCy(dataCy) {
-    return cy.get(`[data-cy="${dataCy}"]`);
-}
-
-function getTableRowById(prevSubjectElements, id) {
-    const prevSubjectElement = prevSubjectElements ? prevSubjectElements[0] : undefined;
-    if (prevSubjectElements && !prevSubjectElements[0]) {
-        throw new Error('`prevSubjectElements[0]` is undefined.');
-    }
-    return (prevSubjectElement ? cy.wrap(prevSubjectElement) : cy.get('body')).first().find(`.Table-SimpleTable tr[data-id="${id}"]`);
-}
-
-function getTableRowByText(prevSubjectElements, text) {
-    const prevSubjectElement = prevSubjectElements ? prevSubjectElements[0] : undefined;
-    if (prevSubjectElements && !prevSubjectElements[0]) {
-        throw new Error('`prevSubjectElements[0]` is undefined.');
-    }
-    return (prevSubjectElement ? cy.wrap(prevSubjectElement) : cy.get('body')).first().contains(`.Table-SimpleTable tr`, text);
-}
-
-function waitForLastRequest(alias, partialRequest, maxRequests, level = 0, callback = ()=>{}) {
-    if (level === maxRequests) {
-        throw new Error(`${maxRequests} requests exceeded`);
-    }
-    // @ts-ignore
-    return cy.wait(alias).then((interception)=>{
-        // @ts-ignore
-        const isMatch = Cypress._.isMatch(interception.request, partialRequest);
-        if (isMatch) {
-            return callback(interception.response);
-        }
-        // eslint-disable-next-line no-console
-        cy.log('Intercepted request', JSON.stringify(interception.request));
-        // @ts-ignore
-        return cy.waitForLastRequest(alias, partialRequest, maxRequests, level + 1, callback);
-    });
-}
-
-const registerMonitorUiCustomCommands = ()=>{
-    Cypress.Commands.add('clickButton', {
-        prevSubject: 'optional'
-    }, clickButton);
-    Cypress.Commands.add('clickLink', clickLink);
-    Cypress.Commands.add('waitForLastRequest', waitForLastRequest);
-    Cypress.Commands.add('clickOutside', clickOutside);
-    Cypress.Commands.add('fill', fill);
-    Cypress.Commands.add('forceCheck', {
-        prevSubject: true
-    }, forceCheck);
-    Cypress.Commands.add('forceClear', {
-        prevSubject: true
-    }, forceClear);
-    Cypress.Commands.add('forceClick', {
-        prevSubject: true
-    }, forceClick);
-    Cypress.Commands.add('forceType', {
-        prevSubject: true
-    }, forceType);
-    Cypress.Commands.add('forceUncheck', {
-        prevSubject: true
-    }, forceUncheck);
-    Cypress.Commands.add('getDataCy', getDataCy);
-    Cypress.Commands.add('getTableRowById', {
-        prevSubject: 'optional'
-    }, getTableRowById);
-    Cypress.Commands.add('getTableRowByText', {
-        prevSubject: 'optional'
-    }, getTableRowByText);
-};
-registerMonitorUiCustomCommands();
-
-export { registerMonitorUiCustomCommands };