@mtes-mct/monitor-ui 3.1.0 → 3.2.0

package/cypress/index.js

@@ -0,0 +1,939 @@
+// 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$1 = 5;
+function clickButton(label, { index = 0, withinSelector } = {}, leftRetries = RETRIES$1) {
+    const preSelector = withinSelector ? `${withinSelector} ` : '';
+    const iconButtonElement = Cypress.$(`${preSelector}button[aria-label="${label}"]`).get(index);
+    const textButtonElement = findElementBytext(`${preSelector}button`, label, { index });
+    const menuItemElement = findElementBytext(`${preSelector}[role="menuitem"]`, label, { index });
+    if (iconButtonElement) {
+        return cy.wrap(iconButtonElement).scrollIntoView().click({ force: true }).wait(250);
+    }
+    if (menuItemElement) {
+        return cy
+            .wrap(menuItemElement)
+            .scrollIntoView()
+            .click({ force: true })
+            .wait(250);
+    }
+    if (textButtonElement) {
+        return cy.wrap(textButtonElement).scrollIntoView().click({ force: true }).wait(250);
+    }
+    if (leftRetries > 0) {
+        return cy.wait(250).then(() => {
+            cy.log(`Retrying (${RETRIES$1 - leftRetries + 1} / ${RETRIES$1})...`);
+            return clickButton(label, { index, withinSelector }, leftRetries - 1);
+        });
+    }
+    throw new Error(`Unable to find button with label "${label}".`);
+}
+
+/**
+ * @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);
+}
+
+// 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 findElementBySelector(selector, { fallbackSelector, index = 0, inElement } = {}) {
+    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) {
+                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) {
+            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;
+}
+
+function waitFor(inMs) {
+    return new Promise(resolve => {
+        setTimeout(resolve, inMs);
+    });
+}
+
+function _isPlaceholder(a) {
+  return a != null && typeof a === 'object' && a['@@functional/placeholder'] === true;
+}
+
+/**
+ * Optimized internal one-arity curry function.
+ *
+ * @private
+ * @category Function
+ * @param {Function} fn The function to curry.
+ * @return {Function} The curried function.
+ */
+
+function _curry1(fn) {
+  return function f1(a) {
+    if (arguments.length === 0 || _isPlaceholder(a)) {
+      return f1;
+    } else {
+      return fn.apply(this, arguments);
+    }
+  };
+}
+
+/**
+ * Optimized internal two-arity curry function.
+ *
+ * @private
+ * @category Function
+ * @param {Function} fn The function to curry.
+ * @return {Function} The curried function.
+ */
+
+function _curry2(fn) {
+  return function f2(a, b) {
+    switch (arguments.length) {
+      case 0:
+        return f2;
+
+      case 1:
+        return _isPlaceholder(a) ? f2 : _curry1(function (_b) {
+          return fn(a, _b);
+        });
+
+      default:
+        return _isPlaceholder(a) && _isPlaceholder(b) ? f2 : _isPlaceholder(a) ? _curry1(function (_a) {
+          return fn(_a, b);
+        }) : _isPlaceholder(b) ? _curry1(function (_b) {
+          return fn(a, _b);
+        }) : fn(a, b);
+    }
+  };
+}
+
+/**
+ * Tests whether or not an object is an array.
+ *
+ * @private
+ * @param {*} val The object to test.
+ * @return {Boolean} `true` if `val` is an array, `false` otherwise.
+ * @example
+ *
+ *      _isArray([]); //=> true
+ *      _isArray(null); //=> false
+ *      _isArray({}); //=> false
+ */
+var _isArray = Array.isArray || function _isArray(val) {
+  return val != null && val.length >= 0 && Object.prototype.toString.call(val) === '[object Array]';
+};
+
+function _isString(x) {
+  return Object.prototype.toString.call(x) === '[object String]';
+}
+
+function _has(prop, obj) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+var toString = Object.prototype.toString;
+
+var _isArguments =
+/*#__PURE__*/
+function () {
+  return toString.call(arguments) === '[object Arguments]' ? function _isArguments(x) {
+    return toString.call(x) === '[object Arguments]';
+  } : function _isArguments(x) {
+    return _has('callee', x);
+  };
+}();
+
+var hasEnumBug = !
+/*#__PURE__*/
+{
+  toString: null
+}.propertyIsEnumerable('toString');
+var nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString', 'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString']; // Safari bug
+
+var hasArgsEnumBug =
+/*#__PURE__*/
+function () {
+
+  return arguments.propertyIsEnumerable('length');
+}();
+
+var contains = function contains(list, item) {
+  var idx = 0;
+
+  while (idx < list.length) {
+    if (list[idx] === item) {
+      return true;
+    }
+
+    idx += 1;
+  }
+
+  return false;
+};
+/**
+ * Returns a list containing the names of all the enumerable own properties of
+ * the supplied object.
+ * Note that the order of the output array is not guaranteed to be consistent
+ * across different JS platforms.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Object
+ * @sig {k: v} -> [k]
+ * @param {Object} obj The object to extract properties from
+ * @return {Array} An array of the object's own properties.
+ * @see R.keysIn, R.values, R.toPairs
+ * @example
+ *
+ *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']
+ */
+
+
+var keys = typeof Object.keys === 'function' && !hasArgsEnumBug ?
+/*#__PURE__*/
+_curry1(function keys(obj) {
+  return Object(obj) !== obj ? [] : Object.keys(obj);
+}) :
+/*#__PURE__*/
+_curry1(function keys(obj) {
+  if (Object(obj) !== obj) {
+    return [];
+  }
+
+  var prop, nIdx;
+  var ks = [];
+
+  var checkArgsLength = hasArgsEnumBug && _isArguments(obj);
+
+  for (prop in obj) {
+    if (_has(prop, obj) && (!checkArgsLength || prop !== 'length')) {
+      ks[ks.length] = prop;
+    }
+  }
+
+  if (hasEnumBug) {
+    nIdx = nonEnumerableProps.length - 1;
+
+    while (nIdx >= 0) {
+      prop = nonEnumerableProps[nIdx];
+
+      if (_has(prop, obj) && !contains(ks, prop)) {
+        ks[ks.length] = prop;
+      }
+
+      nIdx -= 1;
+    }
+  }
+
+  return ks;
+});
+
+/**
+ * Gives a single-word string description of the (native) type of a value,
+ * returning such answers as 'Object', 'Number', 'Array', or 'Null'. Does not
+ * attempt to distinguish user Object types any further, reporting them all as
+ * 'Object'.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.8.0
+ * @category Type
+ * @sig (* -> {*}) -> String
+ * @param {*} val The value to test
+ * @return {String}
+ * @example
+ *
+ *      R.type({}); //=> "Object"
+ *      R.type(1); //=> "Number"
+ *      R.type(false); //=> "Boolean"
+ *      R.type('s'); //=> "String"
+ *      R.type(null); //=> "Null"
+ *      R.type([]); //=> "Array"
+ *      R.type(/[A-z]/); //=> "RegExp"
+ *      R.type(() => {}); //=> "Function"
+ *      R.type(undefined); //=> "Undefined"
+ */
+
+var type =
+/*#__PURE__*/
+_curry1(function type(val) {
+  return val === null ? 'Null' : val === undefined ? 'Undefined' : Object.prototype.toString.call(val).slice(8, -1);
+});
+
+function _arrayFromIterator(iter) {
+  var list = [];
+  var next;
+
+  while (!(next = iter.next()).done) {
+    list.push(next.value);
+  }
+
+  return list;
+}
+
+function _includesWith(pred, x, list) {
+  var idx = 0;
+  var len = list.length;
+
+  while (idx < len) {
+    if (pred(x, list[idx])) {
+      return true;
+    }
+
+    idx += 1;
+  }
+
+  return false;
+}
+
+function _functionName(f) {
+  // String(x => x) evaluates to "x => x", so the pattern may not match.
+  var match = String(f).match(/^function (\w*)/);
+  return match == null ? '' : match[1];
+}
+
+// Based on https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+function _objectIs(a, b) {
+  // SameValue algorithm
+  if (a === b) {
+    // Steps 1-5, 7-10
+    // Steps 6.b-6.e: +0 != -0
+    return a !== 0 || 1 / a === 1 / b;
+  } else {
+    // Step 6.a: NaN == NaN
+    return a !== a && b !== b;
+  }
+}
+
+var _objectIs$1 = typeof Object.is === 'function' ? Object.is : _objectIs;
+
+/**
+ * private _uniqContentEquals function.
+ * That function is checking equality of 2 iterator contents with 2 assumptions
+ * - iterators lengths are the same
+ * - iterators values are unique
+ *
+ * false-positive result will be returned for comparison of, e.g.
+ * - [1,2,3] and [1,2,3,4]
+ * - [1,1,1] and [1,2,3]
+ * */
+
+function _uniqContentEquals(aIterator, bIterator, stackA, stackB) {
+  var a = _arrayFromIterator(aIterator);
+
+  var b = _arrayFromIterator(bIterator);
+
+  function eq(_a, _b) {
+    return _equals(_a, _b, stackA.slice(), stackB.slice());
+  } // if *a* array contains any element that is not included in *b*
+
+
+  return !_includesWith(function (b, aItem) {
+    return !_includesWith(eq, aItem, b);
+  }, b, a);
+}
+
+function _equals(a, b, stackA, stackB) {
+  if (_objectIs$1(a, b)) {
+    return true;
+  }
+
+  var typeA = type(a);
+
+  if (typeA !== type(b)) {
+    return false;
+  }
+
+  if (typeof a['fantasy-land/equals'] === 'function' || typeof b['fantasy-land/equals'] === 'function') {
+    return typeof a['fantasy-land/equals'] === 'function' && a['fantasy-land/equals'](b) && typeof b['fantasy-land/equals'] === 'function' && b['fantasy-land/equals'](a);
+  }
+
+  if (typeof a.equals === 'function' || typeof b.equals === 'function') {
+    return typeof a.equals === 'function' && a.equals(b) && typeof b.equals === 'function' && b.equals(a);
+  }
+
+  switch (typeA) {
+    case 'Arguments':
+    case 'Array':
+    case 'Object':
+      if (typeof a.constructor === 'function' && _functionName(a.constructor) === 'Promise') {
+        return a === b;
+      }
+
+      break;
+
+    case 'Boolean':
+    case 'Number':
+    case 'String':
+      if (!(typeof a === typeof b && _objectIs$1(a.valueOf(), b.valueOf()))) {
+        return false;
+      }
+
+      break;
+
+    case 'Date':
+      if (!_objectIs$1(a.valueOf(), b.valueOf())) {
+        return false;
+      }
+
+      break;
+
+    case 'Error':
+      return a.name === b.name && a.message === b.message;
+
+    case 'RegExp':
+      if (!(a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode)) {
+        return false;
+      }
+
+      break;
+  }
+
+  var idx = stackA.length - 1;
+
+  while (idx >= 0) {
+    if (stackA[idx] === a) {
+      return stackB[idx] === b;
+    }
+
+    idx -= 1;
+  }
+
+  switch (typeA) {
+    case 'Map':
+      if (a.size !== b.size) {
+        return false;
+      }
+
+      return _uniqContentEquals(a.entries(), b.entries(), stackA.concat([a]), stackB.concat([b]));
+
+    case 'Set':
+      if (a.size !== b.size) {
+        return false;
+      }
+
+      return _uniqContentEquals(a.values(), b.values(), stackA.concat([a]), stackB.concat([b]));
+
+    case 'Arguments':
+    case 'Array':
+    case 'Object':
+    case 'Boolean':
+    case 'Number':
+    case 'String':
+    case 'Date':
+    case 'Error':
+    case 'RegExp':
+    case 'Int8Array':
+    case 'Uint8Array':
+    case 'Uint8ClampedArray':
+    case 'Int16Array':
+    case 'Uint16Array':
+    case 'Int32Array':
+    case 'Uint32Array':
+    case 'Float32Array':
+    case 'Float64Array':
+    case 'ArrayBuffer':
+      break;
+
+    default:
+      // Values of other types are only equal if identical.
+      return false;
+  }
+
+  var keysA = keys(a);
+
+  if (keysA.length !== keys(b).length) {
+    return false;
+  }
+
+  var extendedStackA = stackA.concat([a]);
+  var extendedStackB = stackB.concat([b]);
+  idx = keysA.length - 1;
+
+  while (idx >= 0) {
+    var key = keysA[idx];
+
+    if (!(_has(key, b) && _equals(b[key], a[key], extendedStackA, extendedStackB))) {
+      return false;
+    }
+
+    idx -= 1;
+  }
+
+  return true;
+}
+
+/**
+ * Returns `true` if its arguments are equivalent, `false` otherwise. Handles
+ * cyclical data structures.
+ *
+ * Dispatches symmetrically to the `equals` methods of both arguments, if
+ * present.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.15.0
+ * @category Relation
+ * @sig a -> b -> Boolean
+ * @param {*} a
+ * @param {*} b
+ * @return {Boolean}
+ * @example
+ *
+ *      R.equals(1, 1); //=> true
+ *      R.equals(1, '1'); //=> false
+ *      R.equals([1, 2, 3], [1, 2, 3]); //=> true
+ *
+ *      const a = {}; a.v = a;
+ *      const b = {}; b.v = b;
+ *      R.equals(a, b); //=> true
+ */
+
+var equals =
+/*#__PURE__*/
+_curry2(function equals(a, b) {
+  return _equals(a, b, [], []);
+});
+
+function _isObject(x) {
+  return Object.prototype.toString.call(x) === '[object Object]';
+}
+
+/**
+ * Tests whether or not an object is a typed array.
+ *
+ * @private
+ * @param {*} val The object to test.
+ * @return {Boolean} `true` if `val` is a typed array, `false` otherwise.
+ * @example
+ *
+ *      _isTypedArray(new Uint8Array([])); //=> true
+ *      _isTypedArray(new Float32Array([])); //=> true
+ *      _isTypedArray([]); //=> false
+ *      _isTypedArray(null); //=> false
+ *      _isTypedArray({}); //=> false
+ */
+function _isTypedArray(val) {
+  var type = Object.prototype.toString.call(val);
+  return type === '[object Uint8ClampedArray]' || type === '[object Int8Array]' || type === '[object Uint8Array]' || type === '[object Int16Array]' || type === '[object Uint16Array]' || type === '[object Int32Array]' || type === '[object Uint32Array]' || type === '[object Float32Array]' || type === '[object Float64Array]' || type === '[object BigInt64Array]' || type === '[object BigUint64Array]';
+}
+
+/**
+ * Returns the empty value of its argument's type. Ramda defines the empty
+ * value of Array (`[]`), Object (`{}`), String (`''`),
+ * TypedArray (`Uint8Array []`, `Float32Array []`, etc), and Arguments. Other
+ * types are supported if they define `<Type>.empty`,
+ * `<Type>.prototype.empty` or implement the
+ * [FantasyLand Monoid spec](https://github.com/fantasyland/fantasy-land#monoid).
+ *
+ * Dispatches to the `empty` method of the first argument, if present.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.3.0
+ * @category Function
+ * @sig a -> a
+ * @param {*} x
+ * @return {*}
+ * @example
+ *
+ *      R.empty(Just(42));               //=> Nothing()
+ *      R.empty([1, 2, 3]);              //=> []
+ *      R.empty('unicorns');             //=> ''
+ *      R.empty({x: 1, y: 2});           //=> {}
+ *      R.empty(Uint8Array.from('123')); //=> Uint8Array []
+ */
+
+var empty =
+/*#__PURE__*/
+_curry1(function empty(x) {
+  return x != null && typeof x['fantasy-land/empty'] === 'function' ? x['fantasy-land/empty']() : x != null && x.constructor != null && typeof x.constructor['fantasy-land/empty'] === 'function' ? x.constructor['fantasy-land/empty']() : x != null && typeof x.empty === 'function' ? x.empty() : x != null && x.constructor != null && typeof x.constructor.empty === 'function' ? x.constructor.empty() : _isArray(x) ? [] : _isString(x) ? '' : _isObject(x) ? {} : _isArguments(x) ? function () {
+    return arguments;
+  }() : _isTypedArray(x) ? x.constructor.from('') : void 0 // else
+  ;
+});
+
+/**
+ * Returns `true` if the given value is its type's empty value; `false`
+ * otherwise.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Logic
+ * @sig a -> Boolean
+ * @param {*} x
+ * @return {Boolean}
+ * @see R.empty
+ * @example
+ *
+ *      R.isEmpty([1, 2, 3]);           //=> false
+ *      R.isEmpty([]);                  //=> true
+ *      R.isEmpty('');                  //=> true
+ *      R.isEmpty(null);                //=> false
+ *      R.isEmpty({});                  //=> true
+ *      R.isEmpty({length: 0});         //=> false
+ *      R.isEmpty(Uint8Array.from('')); //=> true
+ */
+
+var isEmpty =
+/*#__PURE__*/
+_curry1(function isEmpty(x) {
+  return x != null && equals(x, empty(x));
+});
+
+function checkCheckbox(checkboxInputElement, value) {
+    if (value) {
+        cy.wrap(checkboxInputElement).scrollIntoView().check({ force: true });
+    }
+    else {
+        cy.wrap(checkboxInputElement).scrollIntoView().uncheck({ force: true });
+    }
+}
+
+function checkMultiCheckboxOptions(fieldsetElement, values) {
+    cy.wrap(fieldsetElement).scrollIntoView().find('input[type="checkbox"]').uncheck({ force: true });
+    if (values) {
+        values.forEach(value => {
+            cy.wrap(fieldsetElement).find('label').contains(value).find('input[type="checkbox"]').check({ force: true });
+        });
+    }
+    return fieldsetElement;
+}
+
+function checkMultiRadioOption(fieldsetElement, value) {
+    cy.wrap(fieldsetElement)
+        .find('label')
+        .contains(value)
+        .find('input[type="radio"]')
+        .scrollIntoView()
+        .check({ force: true });
+    return fieldsetElement;
+}
+
+function fillTextarea(textareaElement, value) {
+    if (value) {
+        cy.wrap(textareaElement).scrollIntoView().type(value, { delay: 1, force: true });
+    }
+    else {
+        cy.wrap(textareaElement).scrollIntoView().clear();
+    }
+}
+
+function fillTextInput(textInputElement, value) {
+    if (value) {
+        cy.wrap(textInputElement).scrollIntoView().type(value);
+    }
+    else {
+        cy.wrap(textInputElement).scrollIntoView().clear();
+    }
+}
+
+function pickMultiSelectOptions(cypressMultiSelectInputElement, values) {
+    cypressMultiSelectInputElement
+        .parent()
+        .parent()
+        .parent()
+        .parent()
+        .then(([rsuiteMultiSelectElement]) => {
+        if (!rsuiteMultiSelectElement) {
+            throw new Error('This should never happen.');
+        }
+        const maybeClearButton = rsuiteMultiSelectElement.querySelector('.rs-picker-toggle-clean');
+        if (maybeClearButton) {
+            cy.wrap(maybeClearButton).scrollIntoView().click({ force: true });
+        }
+        if (values) {
+            cy.wrap(rsuiteMultiSelectElement).scrollIntoView().click();
+            cy.get('.rs-picker-picker-check-menu').then(([rsuiteMultiSelectMenu]) => {
+                if (!rsuiteMultiSelectMenu) {
+                    throw new Error('This should never happen.');
+                }
+                const maybeSearchInput = rsuiteMultiSelectMenu.querySelector('.rs-picker-search-bar-input');
+                values.forEach(value => {
+                    if (maybeSearchInput) {
+                        cy.wrap(maybeSearchInput).scrollIntoView().type(value);
+                    }
+                    cy.get('.rs-checkbox-checker').contains(value).scrollIntoView().click({ force: true });
+                });
+                const offsetLeft = rsuiteMultiSelectElement.offsetLeft
+                    ? rsuiteMultiSelectElement.offsetLeft
+                    : (() => {
+                        if (!rsuiteMultiSelectElement.offsetParent) {
+                            throw new Error('`rsuiteMultiSelectElement.offsetParent` is undefined.');
+                        }
+                        return rsuiteMultiSelectElement.offsetParent.offsetLeft;
+                    })();
+                const offsetTop = rsuiteMultiSelectElement.offsetTop !== 0
+                    ? rsuiteMultiSelectElement.offsetTop
+                    : (() => {
+                        if (!rsuiteMultiSelectElement.offsetParent) {
+                            throw new Error('`rsuiteMultiSelectElement.offsetParent` is undefined.');
+                        }
+                        return rsuiteMultiSelectElement.offsetParent.offsetTop;
+                    })();
+                // TODO Investigate that (this should be -1).
+                cy.clickOutside(offsetLeft, offsetTop - 16);
+                cy.wait(250);
+            });
+        }
+    });
+}
+
+function pickSelectOption(cypressSelectInputElement, value) {
+    cypressSelectInputElement
+        .parent()
+        .parent()
+        .parent()
+        .parent()
+        .scrollIntoView()
+        .then(([rsuiteSelectElement]) => {
+        if (!rsuiteSelectElement) {
+            throw new Error('This should never happen.');
+        }
+        const maybeClearButton = rsuiteSelectElement.querySelector('.rs-picker-toggle-clean');
+        if (maybeClearButton) {
+            cy.wrap(maybeClearButton).scrollIntoView().click({ force: true });
+        }
+        if (value) {
+            cy.wrap(rsuiteSelectElement).scrollIntoView().click();
+            cy.get('.rs-picker-select-menu').then(([rsuiteSelectMenu]) => {
+                if (!rsuiteSelectMenu) {
+                    throw new Error('This should never happen.');
+                }
+                const maybeSearchInput = rsuiteSelectMenu.querySelector('.rs-picker-search-bar-input');
+                if (maybeSearchInput) {
+                    cy.wrap(maybeSearchInput).scrollIntoView().type(value);
+                }
+                cy.get('.rs-picker-select-menu-item').contains(value).scrollIntoView().click({ force: true });
+            });
+        }
+    });
+    return cypressSelectInputElement;
+}
+
+/* eslint-disable cypress/no-assigning-return-values */
+const RETRIES = 5;
+function fill(label, value, leftRetries = RETRIES) {
+    // -------------------------------------------------------------------------
+    // If this is a `<label />` element
+    const labelElement = findElementBytext('label', label);
+    if (labelElement) {
+        // -------------------------------------------------------------------------
+        // If the label has a `for` attribute
+        if (!isEmpty(labelElement.htmlFor)) {
+            const htmlforElement = findElementBySelector(`[id="${labelElement.htmlFor}"]`);
+            if (!htmlforElement) {
+                throw new Error(`Could not find the element with [id="${labelElement.htmlFor}"] targetted by label "${label}" (via its \`for\` attribute).`);
+            }
+            const cypressHtmlforElement = cy.get(`[id="${labelElement.htmlFor}"]`);
+            cypressHtmlforElement.then((() => {
+                if (htmlforElement.classList.contains('rs-picker-toggle-textbox')) {
+                    const rsuitePickerElement = htmlforElement.parentElement &&
+                        htmlforElement.parentElement.parentElement &&
+                        htmlforElement.parentElement.parentElement.parentElement
+                        ? htmlforElement.parentElement.parentElement.parentElement.parentElement
+                        : undefined;
+                    if (!rsuitePickerElement) {
+                        throw new Error('This should never happen.');
+                    }
+                    switch (true) {
+                        // Select
+                        case rsuitePickerElement.classList.contains('rs-picker-select'):
+                            pickSelectOption(cypressHtmlforElement, value !== undefined ? String(value) : value);
+                            break;
+                        // Multi Select
+                        case rsuitePickerElement.classList.contains('rs-picker-tag'):
+                            pickMultiSelectOptions(cypressHtmlforElement, Array.isArray(value) && value.length > 0 ? value : undefined);
+                            break;
+                        default:
+                            throw new Error(`\`cy.fill()\` can't handle Rsuite picker with class "${rsuitePickerElement.className}" elements.`);
+                    }
+                    return;
+                }
+                switch (htmlforElement.tagName) {
+                    // Text/Number Input
+                    case 'INPUT':
+                        fillTextInput(htmlforElement, value !== undefined ? String(value) : value);
+                        break;
+                    // Textarea
+                    case 'TEXTAREA':
+                        fillTextarea(htmlforElement, value !== undefined ? String(value) : value);
+                        break;
+                    default:
+                        throw new Error(`\`cy.fill()\` doesn't handle "${htmlforElement.tagName}" elements.`);
+                }
+            }));
+            return;
+        }
+        // -------------------------------------------------------------------------
+        // If the label doesn't have a `for` attribute
+        // Checkbox Input
+        const checkboxInputElement = labelElement.querySelector('input[type="checkbox"]');
+        if (checkboxInputElement) {
+            checkCheckbox(checkboxInputElement, Boolean(value));
+            return;
+        }
+        // Text Input
+        const textInputElement = labelElement.querySelector('input[type="text"]');
+        if (textInputElement) {
+            fillTextInput(textInputElement, String(value));
+            return;
+        }
+        // Textarea
+        const textareaElement = labelElement.querySelector('textarea');
+        if (textareaElement) {
+            fillTextarea(textareaElement, String(value));
+            return;
+        }
+        throw new Error(`Could find neither a checkbox, an input nor a textarea with the label "${label}".`);
+    }
+    // -------------------------------------------------------------------------
+    // If this is a `<legend />` element
+    const legendElement = findElementBytext('legend', label);
+    if (legendElement) {
+        const cypressLegendElement = cy.get('legend').contains(label);
+        cypressLegendElement.then(async () => {
+            await waitFor(500);
+            const fieldsetElement = legendElement.parentElement;
+            if (!fieldsetElement || fieldsetElement.tagName !== 'FIELDSET') {
+                throw new Error(`Could not find parent fieldset of legend element with text "${label}".`);
+            }
+            const isMultiCheckbox = Boolean(fieldsetElement.querySelector('input[type="checkbox"]'));
+            const isMultiRadio = Boolean(fieldsetElement.querySelector('input[type="radio"]'));
+            if (isMultiCheckbox) {
+                checkMultiCheckboxOptions(fieldsetElement, Array.isArray(value) && value.length > 0 ? value : undefined);
+                return;
+            }
+            if (isMultiRadio) {
+                checkMultiRadioOption(fieldsetElement, String(value));
+                return;
+            }
+            throw new Error(`\`cy.fill()\` can't handle the field with legend "${label}".`);
+        });
+        return;
+    }
+    if (leftRetries > 0) {
+        cy.wait(250).then(() => {
+            cy.log(`Retrying (${RETRIES - leftRetries + 1} / ${RETRIES})...`);
+            fill(label, value, leftRetries - 1);
+        });
+        return;
+    }
+    throw new Error(`Could not find label or legend element with text "${label}".`);
+}
+
+function forceClick([subject]) {
+    if (!subject) {
+        throw new Error(`Could not find subject.`);
+    }
+    return subject.click({ force: true });
+}
+
+function getDataCy(dataCy) {
+    return cy.get(`[data-cy="${dataCy}"]`);
+}
+
+Cypress.Commands.add('clickButton', clickButton);
+Cypress.Commands.add('clickLink', (linkText) => cy.get('a').contains(linkText).click());
+/**
+ * @description
+ * Useful to close modals.
+ */
+Cypress.Commands.add('clickOutside', clickOutside);
+/**
+ * @example
+ * ```ts
+ *   cy.fill('Password', 'P422W0Rd')
+ * ```
+ */
+Cypress.Commands.add('fill', fill);
+// Maybe because of https://github.com/cypress-io/cypress/issues/19564
+Cypress.Commands.add('forceClick', { prevSubject: true }, forceClick);
+Cypress.Commands.add('getDataCy', getDataCy);
+//# sourceMappingURL=index.js.map