@mtes-mct/monitor-ui 24.33.0 → 24.34.1

package/cypress/index.js

@@ -1,1145 +1,535 @@
-// 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
+function h(t, n, {
+  fallbackSelector: i,
+  index: r = 0,
+  inElement: c
+} = {}) {
+  const o = n.trim();
+  if (c) {
+    let a, y = 0;
+    return Cypress.$(c).find(t).each(function() {
+      if (!a && Cypress.$(this).text().trim() === o) {
+        if (y < r) {
+          y += 1;
+          return;
         }
-    });
-    cy.wrap(fieldsetElement).find('input[type="checkbox"]').uncheck({
-        force
-    }).wait(250);
-    // If `values` is undefined, we don't need to check anything
-    if (!values) {
+        a = this;
+      }
+    }), !a && i ? (cy.log(`⚠️ Using fallback selector: "${i}"`), Cypress.$(c).find(i)) : a;
+  }
+  let e, s = 0;
+  return Cypress.$(t).each(function() {
+    if (!e && Cypress.$(this).text().trim() === o) {
+      if (s < r) {
+        s += 1;
         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
+      }
+      e = this;
+    }
+  }), !e && i ? (console.warn(`Using fallback selector: "${i}".`), Cypress.$(i)) : e;
+}
+const b = 5;
+function O(t, n, {
+  index: i,
+  prevSubjectElement: r
+}) {
+  const c = h(`${n}button`, t, {
+    index: i,
+    inElement: r
+  });
+  if (c)
+    return c;
+  const o = r ? r.querySelectorAll(`${n}button[aria-label="${t}"]`)[i] : Cypress.$(`${n}button[aria-label="${t}"]`).get(i);
+  if (o)
+    return o;
+  const e = r ? r.querySelectorAll(`${n}button[title="${t}"]`)[i] : Cypress.$(`${n}button[title="${t}"]`).get(i);
+  if (e)
+    return e;
+  const s = h(`${n}[role="button"]`, t, {
+    index: i,
+    inElement: r
+  });
+  if (s)
+    return s;
+  const a = r ? r.querySelectorAll(`${n}[role="button"][aria-label="${t}"]`)[i] : Cypress.$(`${n}[role="button"][aria-label="${t}"]`).get(i);
+  if (a)
+    return a;
+  const y = r ? r.querySelectorAll(`${n}[role="button"][title="${t}"]`)[i] : Cypress.$(`${n}[role="button"][title="${t}"]`).get(i);
+  if (y)
+    return y;
+  const l = h(`${n}[role="menuitem"]`, t, {
+    index: i,
+    inElement: r
+  });
+  if (l)
+    return l;
+}
+function $(t, n, {
+  index: i = 0,
+  withinSelector: r,
+  withoutScroll: c = !1
+} = {}, o = b) {
+  const e = t ? t[0] : void 0;
+  if (t && !t[0])
+    throw new Error("`prevSubjectElements[0]` is undefined.");
+  const s = r ? `${r} ` : "", a = O(n, s, {
+    index: i,
+    prevSubjectElement: e
+  });
+  if (a)
+    return (c ? cy.wrap(a).forceClick() : cy.wrap(a).scrollIntoView().forceClick()).wait(250);
+  if (o > 0)
+    return cy.wait(250).then(() => (cy.log(`Retrying (${b - o + 1} / ${b})...`), $(t, n, { index: i, withinSelector: r, withoutScroll: c }, o - 1)));
+  throw new Error(`Unable to find button with label "${n}".`);
+}
+function R(t) {
+  return cy.get("a").contains(t).click();
+}
+function D(t = 0, n = 0) {
+  cy.log(`Click outside at position: ${t}, ${n}`), cy.get("body").click(t, n, { force: !0 });
+}
+function L(t, n, i, r) {
+  Cypress.log({
+    consoleProps: () => ({
+      "Applied to": t,
+      Elements: 1
+    }),
+    name: "checkCheckbox"
+  }), cy.wrap(t).scrollIntoView({ offset: { left: 0, top: -100 } }), n ? cy.wrap(t).find('input[type="checkbox"]').check({ force: r }).wait(250) : cy.wrap(t).find('input[type="checkbox"]').uncheck({ force: r }).wait(250);
+}
+function P(t, n, i, r) {
+  Cypress.log({
+    consoleProps: () => ({
+      "Applied to": t,
+      Elements: 1
+    }),
+    name: "checkMultiCheckboxOptions"
+  }), cy.wrap(t).scrollIntoView({ offset: { left: 0, top: -100 } }), cy.wrap(t).find('input[type="checkbox"]').uncheck({ force: r }).wait(250), n && (n.forEach((c) => {
+    cy.wrap(t).contains(".rs-checkbox-label", c).closest(".rs-checkbox").find('input[type="checkbox"]').check({ force: r });
+  }), cy.wait(250));
+}
+function q(t, n, i, r) {
+  Cypress.log({
+    consoleProps: () => ({
+      "Applied to": t,
+      Elements: 1
+    }),
+    name: "checkMultiRadioOption"
+  }), cy.wrap(t).scrollIntoView({ offset: { left: 0, top: -100 } }).find("label").contains(n).click({ force: r }).wait(250);
+}
+const _ = {
+  delay: 10,
+  force: !0,
+  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
+function p(t) {
+  throw new Error(`[monitor-ui > Cypress] ${t}`);
+}
+function V(t, n, i, r, c) {
+  Cypress.log({
+    consoleProps: () => ({
+      "Applied to": t,
+      Elements: 1
+    }),
+    name: "fillDatePicker"
+  });
+  const o = t.querySelectorAll("input");
+  o.length !== 4 && o.length !== 6 && p(`Expected to find 4 or 6 inputs within in DatePicker but found ${o.length}.`);
+  const e = o.length === 6;
+  if (!n)
+    cy.wrap(t).find('[aria-label="Jour"]').clear({ force: r }), cy.wrap(t).find('[aria-label="Mois"]').clear({ force: r }), cy.wrap(t).find('[aria-label="Année"]').clear({ force: r }), e && (cy.wrap(t).find('[aria-label="Heure"]').clear({ force: r }), cy.wrap(t).find('[aria-label="Minute"]').clear({ force: r }));
+  else {
+    const [s, a, y] = n;
+    if (cy.wrap(t).find('[aria-label="Jour"]').type(String(y).padStart(2, "0"), { delay: c, force: r }), cy.wrap(t).find('[aria-label="Mois"]').type(String(a).padStart(2, "0"), { delay: c, force: r }), cy.wrap(t).find('[aria-label="Année"]').type(String(s), { delay: c, force: r }), e) {
+      const [l, k] = n.slice(3);
+      cy.wrap(t).find('[aria-label="Heure"]').type(String(l).padStart(2, "0"), { delay: c, force: r }), cy.wrap(t).find('[aria-label="Minute"]').type(String(k).padStart(2, "0"), { delay: c, force: r });
+    }
+  }
+  cy.wait(250), cy.get("body").type("{esc}", { delay: c, force: r }), cy.wait(250);
+}
+function U(t, n, i, r, c) {
+  Cypress.log({
+    consoleProps: () => ({
+      "Applied to": t,
+      Elements: 1
+    }),
+    name: "fillDateRangePicker"
+  });
+  const o = t.querySelectorAll("input");
+  o.length !== 7 && o.length !== 11 && p(`Expected to find 7 or 11 inputs within in DatePicker but found ${o.length}.`);
+  const e = o.length !== 7;
+  if (!n)
+    cy.wrap(t).find('[aria-label="Jour de début"]').clear({ force: r }), cy.wrap(t).find('[aria-label="Mois de début"]').clear({ force: r }), cy.wrap(t).find('[aria-label="Année de début"]').clear({ force: r }), e && (cy.wrap(t).find('[aria-label="Heure de début"]').clear({ force: r }), cy.wrap(t).find('[aria-label="Minute de début"]').clear({ force: r })), cy.wrap(t).find('[aria-label="Jour de fin"]').clear({ force: r }), cy.wrap(t).find('[aria-label="Mois de fin"]').clear({ force: r }), cy.wrap(t).find('[aria-label="Année de fin"]').clear({ force: r }), e && (cy.wrap(t).find('[aria-label="Heure de fin"]').clear({ force: r }), cy.wrap(t).find('[aria-label="Minute de fin"]').clear({ force: r }));
+  else {
+    const [s, a] = n, [y, l, k, A, I] = s, [T, x, M, F, B] = a;
+    cy.wrap(t).find('[aria-label="Jour de début"]').type(String(k).padStart(2, "0"), { delay: c, force: r }), cy.wrap(t).find('[aria-label="Mois de début"]').type(String(l).padStart(2, "0"), { delay: c, force: r }), cy.wrap(t).find('[aria-label="Année de début"]').type(String(y), { force: r }), e && (cy.wrap(t).find('[aria-label="Heure de début"]').type(String(A).padStart(2, "0"), { delay: c, force: r }), cy.wrap(t).find('[aria-label="Minute de début"]').type(String(I).padStart(2, "0"), { force: r })), cy.wrap(t).find('[aria-label="Jour de fin"]').type(String(M).padStart(2, "0"), { delay: c, force: r }), cy.wrap(t).find('[aria-label="Mois de fin"]').type(String(x).padStart(2, "0"), { delay: c, force: r }), cy.wrap(t).find('[aria-label="Année de fin"]').type(String(T), { force: r }), e && (cy.wrap(t).find('[aria-label="Heure de fin"]').type(String(F).padStart(2, "0"), { delay: c, force: r }), cy.wrap(t).find('[aria-label="Minute de fin"]').type(String(B).padStart(2, "0"), { delay: c, force: r }));
+  }
+  cy.wait(250), cy.get("body").type("{esc}", { delay: c, force: r }), cy.wait(250);
+}
+function N(t, n, i, r, c) {
+  Cypress.log({
+    consoleProps: () => ({
+      "Applied to": t,
+      Elements: 1
+    }),
+    name: "fillNumberInput"
+  }), cy.wrap(t).scrollIntoView({ offset: { left: 0, top: -100 } }), cy.wrap(t).find('input[type="number"]').clear({ force: r }).wait(250), n && cy.wrap(t).find('input[type="number"]').type(String(n), { delay: c, force: r }).wait(250);
+}
+function H(t, n, i, r, c) {
+  Cypress.log({
+    consoleProps: () => ({
+      "Applied to": t,
+      Elements: 1
+    }),
+    name: "fillTextarea"
+  }), cy.wrap(t).scrollIntoView({ offset: { left: 0, top: -100 } }), cy.wrap(t).find("textarea").clear({ force: r }).wait(250), n && cy.wrap(t).find("textarea").type(n, { delay: c, force: r }).wait(250);
+}
+function g(t, n, i, r, c) {
+  Cypress.log({
+    consoleProps: () => ({
+      "Applied to": t,
+      Elements: 1
+    }),
+    name: "fillTextInput"
+  }), cy.wrap(t).scrollIntoView({ offset: { left: 0, top: -100 } }), cy.wrap(t).find("input").clear({ force: r }).wait(250), n && cy.wrap(t).find("input").type(n, { delay: c, force: r }).wait(250);
+}
+function C(t, n, i, r, c, o = "option") {
+  Cypress.log({
+    consoleProps: () => ({
+      "Applied to": t,
+      Elements: 1
+    }),
+    name: "pickCheckPickerOptions"
+  }), cy.wrap(t).scrollIntoView({ offset: { left: 0, top: -100 } }), t.querySelector(".rs-stack > .rs-stack-item > .rs-picker-clean") && cy.wrap(t).find(".rs-stack > .rs-stack-item > .rs-picker-clean").click({ force: r }).wait(250), n && (cy.wrap(t).find(".rs-picker-toggle").click({ force: r }), cy.wrap(t).find(".rs-picker-popup").then(([s]) => {
+    s || p(`Could not find '.rs-picker-popup' in in field with label "${i}". Did the picker open?`);
+    const a = s.querySelector('input[role="searchbox"]');
+    n.forEach((y) => {
+      a && cy.wrap(s).find('input[role="searchbox"]').clear().type(y, { delay: c, force: r }).wait(250), cy.wrap(s).find(`[role="${o}"]`).contains(y).first().scrollIntoView().click({ force: r });
+    }), cy.get("body").type("{esc}", { delay: c, force: r }), cy.wait(250);
+  }));
+}
+function J(t, n, i, r, c) {
+  Cypress.log({
+    consoleProps: () => ({
+      "Applied to": t,
+      Elements: 1
+    }),
+    name: "pickMultiCascaderOptions"
+  }), cy.wrap(t).scrollIntoView({ offset: { left: 0, top: -100 } }), t.querySelector(".rs-stack > .rs-stack-item > .rs-picker-clean") && cy.wrap(t).find(".rs-stack > .rs-stack-item > .rs-picker-clean").click({ force: r }).wait(250), n && (cy.wrap(t).find(".rs-picker-toggle").click({ force: r }), cy.wrap(t).find(".rs-picker-popup").then(([e]) => {
+    e || p(`Could not find '.rs-picker-popup' in in field with label "${i}". Did the picker open?`), e.querySelector('input[role="searchbox"]') || p(
+      p(
+        `\`cy.fill()\` can't handle the MultiCascader with \`<label>\` "${i}" because it's not \`searchable\`.`
+      )
+    ), n.forEach((a) => {
+      cy.wrap(e).find('input[role="searchbox"]').clear().type(a, { delay: c, force: r }).wait(250), cy.wrap(e).find('[role="treeitem"]').contains(a).first().scrollIntoView().click({ force: r });
+    }), cy.get("body").type("{esc}", { delay: c, force: r }), cy.wait(250);
+  }));
+}
+function W(t, n, i, r, c) {
+  Cypress.log({
+    consoleProps: () => ({
+      "Applied to": t,
+      Elements: 1
+    }),
+    name: "pickMultiSelectOptions"
+  }), cy.wrap(t).scrollIntoView({ offset: { left: 0, top: -100 } }), t.querySelector(".rs-stack > .rs-stack-item > .rs-picker-clean") && cy.wrap(t).find(".rs-stack > .rs-stack-item > .rs-picker-clean").click({ force: r }).wait(250), n && (cy.wrap(t).find(".rs-picker-toggle").click({ force: r }), cy.wrap(t).get(".rs-picker-popup").then(([e]) => {
+    e || p(`Could not find '.rs-picker-popup' in in field with label "${i}". Did the picker open?`), n.forEach((s) => {
+      t.querySelector(".rs-picker-search-input > input") && cy.wrap(t).find(".rs-picker-search-input > input").type(s, { delay: c, force: r }).wait(250), cy.wrap(e).find('[role="option"]').contains(s).first().scrollIntoView().click({ force: r });
+    }), cy.get("body").type("{esc}", { delay: c, force: r }), cy.wait(250);
+  }));
+}
+function X(t, n, i, r, c) {
+  Cypress.log({
+    consoleProps: () => ({
+      "Applied to": t,
+      Elements: 1
+    }),
+    name: "pickSearchOption"
+  }), cy.wrap(t).scrollIntoView({ offset: { left: 0, top: -100 } }), t.querySelector(".Field-Search__ClearButton") && cy.wrap(t).find(".Field-Search__ClearButton").click({ force: r }).wait(250), n && (cy.wrap(t).find('input[role="combobox"]').type(n, { delay: c, force: r }), cy.wrap(t).get(".rs-picker-popup").then(([e]) => {
+    cy.wrap(e).find('[role="option"]').first().scrollIntoView().click({ force: r }).wait(250);
+  }));
+}
+function Y(t, n, i, r, c) {
+  Cypress.log({
+    consoleProps: () => ({
+      "Applied to": t,
+      Elements: 1
+    }),
+    name: "pickSelectOption"
+  }), cy.wrap(t).scrollIntoView({ offset: { left: 0, top: -100 } }), t.querySelector(".rs-stack > .rs-stack-item > .rs-picker-clean") && cy.wrap(t).find(".rs-stack > .rs-stack-item > .rs-picker-clean").click({ force: r }).wait(250), n && (cy.wrap(t).find(".rs-stack > .rs-stack-item > .rs-picker-caret-icon").click({ force: r }).wait(250), cy.wrap(t).get(".rs-picker-popup").then(([e]) => {
+    e || p(`Could not find '.rs-picker-popup' in in field with label "${i}". Did the picker open?`), e.querySelector('input[role="searchbox"]') && cy.wrap(e).find('input[role="searchbox"]').type(n, { delay: c, force: r }).wait(250), cy.wrap(e).find('[role="option"]').contains(n).scrollIntoView().click({ force: r }).wait(250);
+  }));
+}
+const d = (t, n) => p(
+  `\`value\` should be of type \`${t}\` in \`cy.fill(label, value)\` when used on a <${n} />.`
+);
+function z(t, n) {
+  t === void 0 || typeof t == "boolean" || d("boolean | undefined", n);
+}
+function j(t, n) {
+  t !== void 0 && (Array.isArray(t) && (t.length === 3 || t.length === 5) && t.every((i) => typeof i == "number") || d("DateTuple | DateWithTimeTuple | undefined", n));
+}
+function G(t, n) {
+  t !== void 0 && (Array.isArray(t) && t.length === 2 && (Array.isArray(t[0]) && t[0].length === 3 && t[1].length === 3 || Array.isArray(t[0]) && t[0].length === 5 && t[1].length === 5) && t.every(
+    (i) => Array.isArray(i) && i.every((r) => typeof r == "number")
+  ) || d("DateRangeTuple | DateWithTimeRangeTuple | undefined", n));
+}
+function K(t, n) {
+  t === void 0 || typeof t == "number" || d("number | undefined", n);
+}
+function Q(t, n) {
+  typeof t != "string" && d("string", n);
+}
+function u(t, n) {
+  t === void 0 || typeof t == "string" || d("string | undefined", n);
+}
+function f(t, n) {
+  t !== void 0 && (Array.isArray(t) && t.every((i) => typeof i == "string") || d("string[] | undefined", n));
+}
+const Z = 100;
+function S(t, n, i = 0) {
+  let r = t, c = 0, o = -1;
+  for (; o < Z; ) {
+    if (o += 1, r = r.parentElement, !r)
+      return;
+    if (r.matches(n)) {
+      if (c === i)
+        return r;
+      c += 1;
+    }
+  }
+}
+let w;
+function m(t, n, i = {}) {
+  const r = { ..._, ...i };
+  w || (w = r.retries), Cypress.log({
+    consoleProps: () => ({
+      "Left Retries": r.retries
+    }),
+    message: `Filling field with label/legend "${t}" with value "${JSON.stringify(n)}".`,
+    name: "fill"
+  });
+  try {
+    const c = h("label", t, { index: r.index });
+    if (c) {
+      const e = S(c, ".Element-Field");
+      switch (e || p(
+        `Could not find '.Element-Field' in field with label "${t}" at index "${r.index}".`
+      ), !0) {
+        // ---------------------------------------------------------------------
+        // Checkbox
+        case e.classList.contains("Field-Checkbox"):
+          z(n, "Checkbox"), L(e, n, t, r.force);
+          return;
+        // ---------------------------------------------------------------------
+        // CheckPicker
+        case e.classList.contains("Field-CheckPicker"):
+          f(n, "CheckPicker"), C(e, n, t, r.force, r.delay);
+          return;
+        // ---------------------------------------------------------------------
+        // CheckTreePicker
+        case e.classList.contains("Field-CheckTreePicker"):
+          f(n, "CheckTreePicker"), C(
+            e,
+            n,
+            t,
+            r.force,
+            r.delay,
+            "treeitem"
+          );
+          return;
+        // ---------------------------------------------------------------------
+        // MultiCascader
+        case e.classList.contains("Field-MultiCascader"):
+          f(n, "MultiCascader"), J(e, n, t, r.force, r.delay);
+          return;
+        // ---------------------------------------------------------------------
+        // MultiSelect
+        case e.classList.contains("Field-MultiSelect"):
+          f(n, "MultiSelect"), W(e, n, t, r.force, r.delay);
+          return;
+        // ---------------------------------------------------------------------
+        // Search
+        case e.classList.contains("Field-Search"):
+          u(n, "Search"), X(e, n, t, r.force, r.delay);
+          return;
+        // ---------------------------------------------------------------------
+        // Select
+        case e.classList.contains("Field-Select"):
+          u(n, "Select"), Y(e, n, t, r.force, r.delay);
+          return;
+        // ---------------------------------------------------------------------
+        // NumberInput
+        case e.classList.contains("Field-NumberInput"):
+          K(n, "TextInput"), N(e, n, t, r.force, r.delay);
+          return;
+        // ---------------------------------------------------------------------
+        // Textarea
+        case e.classList.contains("Field-Textarea"):
+          u(n, "Textarea"), H(e, n, t, r.force, r.delay);
+          return;
+        // ---------------------------------------------------------------------
+        //  TextInput
+        case e.classList.contains("Field-TextInput"):
+          u(n, "TextInput"), g(e, n, t, r.force, r.delay);
+          return;
+        // ---------------------------------------------------------------------
+        //  PhoneInput
+        case e.classList.contains("Field-PhoneInput"):
+          u(n, "PhoneInput"), g(e, n, t, r.force, r.delay);
+          return;
+        // ---------------------------------------------------------------------
+        //  LinkInput
+        case e.classList.contains("Field-LinkInput"):
+          u(n, "LinkInput"), g(e, n, t, r.force, r.delay);
+          return;
+        default:
+          p(`\`cy.fill()\` can't handle field with \`<label>\` "${t}".`);
+      }
+    }
+    const o = h("legend", t, { index: r.index });
+    if (o) {
+      const e = S(o, ".Element-Fieldset");
+      switch (e || p(
+        `Could not find '.Element-Fieldset' in field with \`<legend />\` "${t}" at index "${r.index}".`
+      ), !0) {
+        // ---------------------------------------------------------------------
+        // DatePicker
+        case e.classList.contains("Field-DatePicker"):
+          j(n, "DatePicker"), V(e, n, t, r.force, r.delay);
+          return;
+        // ---------------------------------------------------------------------
+        // DateRangePicker
+        case e.classList.contains("Field-DateRangePicker"):
+          G(n, "DateRangePicker"), U(e, n, t, r.force, r.delay);
+          return;
+        // ---------------------------------------------------------------------
+        // MultiCheckbox
+        case e.classList.contains("Field-MultiCheckbox"):
+          f(n, "MultiCheckbox"), P(e, n, t, r.force);
+          return;
+        // ---------------------------------------------------------------------
+        // MultiRadio
+        case e.classList.contains("Field-MultiRadio"):
+          Q(n, "MultiRadio"), q(e, n, t, r.force);
+          return;
+        default:
+          p(`\`cy.fill()\` can't handle the input element in field with \`<legend>\` "${t}".`);
+      }
+    }
+    p(`Could not find a field labelled by a \`<label />\` or \`<legend />\` "${t}".`);
+  } catch (c) {
+    if (r.retries > 0) {
+      cy.wait(250).then(() => {
+        cy.log(
+          `[monitor-ui > Cypress] Retrying (${w - r.retries + 1} / ${w})...`
+        ), m(t, n, {
+          ...r,
+          retries: r.retries - 1
         });
-        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;
+      });
+      return;
     }
-    cy.wrap(fieldElement).find('textarea').type(value, {
-        delay,
-        force
-    }).wait(250);
-}
-
-function fillTextInput(fieldElement, value, _label, force, delay) {
+    const o = c instanceof Error ? c : new Error(String(c));
     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);
+      consoleProps: () => ({
+        err: c,
+        label: t,
+        value: n
+      }),
+      displayName: "ERROR",
+      message: String(o.message),
+      name: "fill"
+    }).error(o), p(
+      [
+        `Could not find or fill field with label or legend "${t}" at index "${r.index}" after ${w} attempts.`,
+        `This error was thrown: “${o.message}”`,
+        'Please check the Cypress "- ERROR" log above for more details.'
+      ].join(`
+`)
+    );
+  }
+}
+function E(t, n = {}) {
+  if (Cypress.log({
+    consoleProps: () => ({
+      "Applied to": t,
+      Elements: 1
+    }),
+    name: "forceCheck"
+  }), !t)
+    throw new Error("Could not find subject.");
+  return cy.wrap(t).check({ ...n, force: !0 });
+}
+function v(t, n = {}) {
+  if (Cypress.log({
+    consoleProps: () => ({
+      "Applied to": t,
+      Elements: 1
+    }),
+    name: "forceClear"
+  }), !t)
+    throw new Error("Could not find subject.");
+  return cy.wrap(t).clear({ ...n, force: !0 });
+}
+function tt(t, n = {}) {
+  if (Cypress.log({
+    consoleProps: () => ({
+      "Applied to": t,
+      Elements: 1
+    }),
+    name: "forceClick"
+  }), !t)
+    throw new Error("Could not find subject.");
+  return cy.wrap(t).click({ ...n, force: !0 });
+}
+function rt(t, n, i = {}) {
+  if (Cypress.log({
+    consoleProps: () => ({
+      "Applied to": t,
+      Elements: 1
+    }),
+    name: "forceType"
+  }), !t)
+    throw new Error("Could not find subject.");
+  return cy.wrap(t).type(n, { ...i, force: !0 });
+}
+function nt(t, n = {}) {
+  if (Cypress.log({
+    consoleProps: () => ({
+      "Applied to": t,
+      Elements: 1
+    }),
+    name: "forceUncheck"
+  }), !t)
+    throw new Error("Could not find subject.");
+  return cy.wrap(t).uncheck({ ...n, force: !0 });
+}
+function et(t) {
+  return cy.get(`[data-cy="${t}"]`);
+}
+function it(t, n) {
+  const i = t ? t[0] : void 0;
+  if (t && !t[0])
+    throw new Error("`prevSubjectElements[0]` is undefined.");
+  return (i ? cy.wrap(i) : cy.get("body")).first().find(`.Table-SimpleTable tr[data-id="${n}"]`);
+}
+function ct(t, n) {
+  const i = t ? t[0] : void 0;
+  if (t && !t[0])
+    throw new Error("`prevSubjectElements[0]` is undefined.");
+  return (i ? cy.wrap(i) : cy.get("body")).first().contains(".Table-SimpleTable tr", n);
+}
+function ot(t, n, i, r = 0, c = () => {
+}) {
+  if (r === i)
+    throw new Error(`${i} requests exceeded`);
+  return cy.wait(t).then((o) => Cypress._.isMatch(o.request, n) ? c(o.response) : (cy.log("Intercepted request", JSON.stringify(o.request)), cy.waitForLastRequest(t, n, i, r + 1, c)));
+}
+const at = () => {
+  typeof Cypress > "u" || (Cypress.Commands.add("clickButton", { prevSubject: "optional" }, $), Cypress.Commands.add("clickLink", R), Cypress.Commands.add("waitForLastRequest", ot), Cypress.Commands.add("clickOutside", D), Cypress.Commands.add("fill", m), Cypress.Commands.add("forceCheck", { prevSubject: !0 }, E), Cypress.Commands.add("forceClear", { prevSubject: !0 }, v), Cypress.Commands.add("forceClick", { prevSubject: !0 }, tt), Cypress.Commands.add("forceType", { prevSubject: !0 }, rt), Cypress.Commands.add("forceUncheck", { prevSubject: !0 }, nt), Cypress.Commands.add("getDataCy", et), Cypress.Commands.add("getTableRowById", { prevSubject: "optional" }, it), Cypress.Commands.add("getTableRowByText", { prevSubject: "optional" }, ct));
+};
+export {
+  at as registerMonitorUiCustomCommands
 };
-registerMonitorUiCustomCommands();
-
-export { registerMonitorUiCustomCommands };
+//# sourceMappingURL=index.js.map