0.2.0 - Mid migration

web/node_modules/@testing-library/dom/dist/queries/all-utils.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _matches = require("../matches");
+
+Object.keys(_matches).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _matches[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _matches[key];
+    }
+  });
+});
+
+var _getNodeText = require("../get-node-text");
+
+Object.keys(_getNodeText).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _getNodeText[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _getNodeText[key];
+    }
+  });
+});
+
+var _queryHelpers = require("../query-helpers");
+
+Object.keys(_queryHelpers).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _queryHelpers[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _queryHelpers[key];
+    }
+  });
+});
+
+var _config = require("../config");
+
+Object.keys(_config).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _config[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _config[key];
+    }
+  });
+});

web/node_modules/@testing-library/dom/dist/queries/alt-text.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findByAltText = exports.findAllByAltText = exports.getAllByAltText = exports.getByAltText = exports.queryAllByAltText = exports.queryByAltText = void 0;
+
+var _queryHelpers = require("../query-helpers");
+
+var _helpers = require("../helpers");
+
+var _allUtils = require("./all-utils");
+
+const queryAllByAltText = (container, alt, {
+  exact = true,
+  collapseWhitespace,
+  trim,
+  normalizer
+} = {}) => {
+  (0, _helpers.checkContainerType)(container);
+  const matcher = exact ? _allUtils.matches : _allUtils.fuzzyMatches;
+  const matchNormalizer = (0, _allUtils.makeNormalizer)({
+    collapseWhitespace,
+    trim,
+    normalizer
+  });
+  return Array.from(container.querySelectorAll('img,input,area')).filter(node => matcher(node.getAttribute('alt'), node, alt, matchNormalizer));
+};
+
+const getMultipleError = (c, alt) => `Found multiple elements with the alt text: ${alt}`;
+
+const getMissingError = (c, alt) => `Unable to find an element with the alt text: ${alt}`;
+
+const queryAllByAltTextWithSuggestions = (0, _queryHelpers.wrapAllByQueryWithSuggestion)(queryAllByAltText, queryAllByAltText.name, 'queryAll');
+exports.queryAllByAltText = queryAllByAltTextWithSuggestions;
+const [queryByAltText, getAllByAltText, getByAltText, findAllByAltText, findByAltText] = (0, _allUtils.buildQueries)(queryAllByAltText, getMultipleError, getMissingError);
+exports.findByAltText = findByAltText;
+exports.findAllByAltText = findAllByAltText;
+exports.getByAltText = getByAltText;
+exports.getAllByAltText = getAllByAltText;
+exports.queryByAltText = queryByAltText;

web/node_modules/@testing-library/dom/dist/queries/display-value.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findByDisplayValue = exports.findAllByDisplayValue = exports.getAllByDisplayValue = exports.getByDisplayValue = exports.queryAllByDisplayValue = exports.queryByDisplayValue = void 0;
+
+var _queryHelpers = require("../query-helpers");
+
+var _helpers = require("../helpers");
+
+var _allUtils = require("./all-utils");
+
+const queryAllByDisplayValue = (container, value, {
+  exact = true,
+  collapseWhitespace,
+  trim,
+  normalizer
+} = {}) => {
+  (0, _helpers.checkContainerType)(container);
+  const matcher = exact ? _allUtils.matches : _allUtils.fuzzyMatches;
+  const matchNormalizer = (0, _allUtils.makeNormalizer)({
+    collapseWhitespace,
+    trim,
+    normalizer
+  });
+  return Array.from(container.querySelectorAll(`input,textarea,select`)).filter(node => {
+    if (node.tagName === 'SELECT') {
+      const selectedOptions = Array.from(node.options).filter(option => option.selected);
+      return selectedOptions.some(optionNode => matcher((0, _allUtils.getNodeText)(optionNode), optionNode, value, matchNormalizer));
+    } else {
+      return matcher(node.value, node, value, matchNormalizer);
+    }
+  });
+};
+
+const getMultipleError = (c, value) => `Found multiple elements with the display value: ${value}.`;
+
+const getMissingError = (c, value) => `Unable to find an element with the display value: ${value}.`;
+
+const queryAllByDisplayValueWithSuggestions = (0, _queryHelpers.wrapAllByQueryWithSuggestion)(queryAllByDisplayValue, queryAllByDisplayValue.name, 'queryAll');
+exports.queryAllByDisplayValue = queryAllByDisplayValueWithSuggestions;
+const [queryByDisplayValue, getAllByDisplayValue, getByDisplayValue, findAllByDisplayValue, findByDisplayValue] = (0, _allUtils.buildQueries)(queryAllByDisplayValue, getMultipleError, getMissingError);
+exports.findByDisplayValue = findByDisplayValue;
+exports.findAllByDisplayValue = findAllByDisplayValue;
+exports.getByDisplayValue = getByDisplayValue;
+exports.getAllByDisplayValue = getAllByDisplayValue;
+exports.queryByDisplayValue = queryByDisplayValue;

web/node_modules/@testing-library/dom/dist/queries/index.js

@@ -0,0 +1,109 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _labelText = require("./label-text");
+
+Object.keys(_labelText).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _labelText[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _labelText[key];
+    }
+  });
+});
+
+var _placeholderText = require("./placeholder-text");
+
+Object.keys(_placeholderText).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _placeholderText[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _placeholderText[key];
+    }
+  });
+});
+
+var _text = require("./text");
+
+Object.keys(_text).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _text[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _text[key];
+    }
+  });
+});
+
+var _displayValue = require("./display-value");
+
+Object.keys(_displayValue).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _displayValue[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _displayValue[key];
+    }
+  });
+});
+
+var _altText = require("./alt-text");
+
+Object.keys(_altText).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _altText[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _altText[key];
+    }
+  });
+});
+
+var _title = require("./title");
+
+Object.keys(_title).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _title[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _title[key];
+    }
+  });
+});
+
+var _role = require("./role");
+
+Object.keys(_role).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _role[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _role[key];
+    }
+  });
+});
+
+var _testId = require("./test-id");
+
+Object.keys(_testId).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _testId[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _testId[key];
+    }
+  });
+});

web/node_modules/@testing-library/dom/dist/queries/label-text.js

@@ -0,0 +1,152 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findByLabelText = exports.findAllByLabelText = exports.getByLabelText = exports.getAllByLabelText = exports.queryByLabelText = exports.queryAllByLabelText = void 0;
+
+var _config = require("../config");
+
+var _helpers = require("../helpers");
+
+var _labelHelpers = require("../label-helpers");
+
+var _allUtils = require("./all-utils");
+
+function queryAllLabels(container) {
+  return Array.from(container.querySelectorAll('label,input')).map(node => {
+    return {
+      node,
+      textToMatch: (0, _labelHelpers.getLabelContent)(node)
+    };
+  }).filter(({
+    textToMatch
+  }) => textToMatch !== null);
+}
+
+const queryAllLabelsByText = (container, text, {
+  exact = true,
+  trim,
+  collapseWhitespace,
+  normalizer
+} = {}) => {
+  const matcher = exact ? _allUtils.matches : _allUtils.fuzzyMatches;
+  const matchNormalizer = (0, _allUtils.makeNormalizer)({
+    collapseWhitespace,
+    trim,
+    normalizer
+  });
+  const textToMatchByLabels = queryAllLabels(container);
+  return textToMatchByLabels.filter(({
+    node,
+    textToMatch
+  }) => matcher(textToMatch, node, text, matchNormalizer)).map(({
+    node
+  }) => node);
+};
+
+const queryAllByLabelText = (container, text, {
+  selector = '*',
+  exact = true,
+  collapseWhitespace,
+  trim,
+  normalizer
+} = {}) => {
+  (0, _helpers.checkContainerType)(container);
+  const matcher = exact ? _allUtils.matches : _allUtils.fuzzyMatches;
+  const matchNormalizer = (0, _allUtils.makeNormalizer)({
+    collapseWhitespace,
+    trim,
+    normalizer
+  });
+  const matchingLabelledElements = Array.from(container.querySelectorAll('*')).filter(element => {
+    return (0, _labelHelpers.getRealLabels)(element).length || element.hasAttribute('aria-labelledby');
+  }).reduce((labelledElements, labelledElement) => {
+    const labelList = (0, _labelHelpers.getLabels)(container, labelledElement, {
+      selector
+    });
+    labelList.filter(label => Boolean(label.formControl)).forEach(label => {
+      if (matcher(label.content, label.formControl, text, matchNormalizer) && label.formControl) labelledElements.push(label.formControl);
+    });
+    const labelsValue = labelList.filter(label => Boolean(label.content)).map(label => label.content);
+    if (matcher(labelsValue.join(' '), labelledElement, text, matchNormalizer)) labelledElements.push(labelledElement);
+
+    if (labelsValue.length > 1) {
+      labelsValue.forEach((labelValue, index) => {
+        if (matcher(labelValue, labelledElement, text, matchNormalizer)) labelledElements.push(labelledElement);
+        const labelsFiltered = [...labelsValue];
+        labelsFiltered.splice(index, 1);
+
+        if (labelsFiltered.length > 1) {
+          if (matcher(labelsFiltered.join(' '), labelledElement, text, matchNormalizer)) labelledElements.push(labelledElement);
+        }
+      });
+    }
+
+    return labelledElements;
+  }, []).concat( // TODO: Remove ignore after `queryAllByAttribute` will be moved to TS
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  (0, _allUtils.queryAllByAttribute)('aria-label', container, text, {
+    exact,
+    normalizer: matchNormalizer
+  }));
+  return Array.from(new Set(matchingLabelledElements)).filter(element => element.matches(selector));
+}; // the getAll* query would normally look like this:
+// const getAllByLabelText = makeGetAllQuery(
+//   queryAllByLabelText,
+//   (c, text) => `Unable to find a label with the text of: ${text}`,
+// )
+// however, we can give a more helpful error message than the generic one,
+// so we're writing this one out by hand.
+
+
+const getAllByLabelText = (container, text, ...rest) => {
+  const els = queryAllByLabelText(container, text, ...rest);
+
+  if (!els.length) {
+    const labels = queryAllLabelsByText(container, text, ...rest);
+
+    if (labels.length) {
+      const tagNames = labels.map(label => getTagNameOfElementAssociatedWithLabelViaFor(container, label)).filter(tagName => !!tagName);
+
+      if (tagNames.length) {
+        throw (0, _config.getConfig)().getElementError(tagNames.map(tagName => `Found a label with the text of: ${text}, however the element associated with this label (<${tagName} />) is non-labellable [https://html.spec.whatwg.org/multipage/forms.html#category-label]. If you really need to label a <${tagName} />, you can use aria-label or aria-labelledby instead.`).join('\n\n'), container);
+      } else {
+        throw (0, _config.getConfig)().getElementError(`Found a label with the text of: ${text}, however no form control was found associated to that label. Make sure you're using the "for" attribute or "aria-labelledby" attribute correctly.`, container);
+      }
+    } else {
+      throw (0, _config.getConfig)().getElementError(`Unable to find a label with the text of: ${text}`, container);
+    }
+  }
+
+  return els;
+};
+
+function getTagNameOfElementAssociatedWithLabelViaFor(container, label) {
+  const htmlFor = label.getAttribute('for');
+
+  if (!htmlFor) {
+    return null;
+  }
+
+  const element = container.querySelector(`[id="${htmlFor}"]`);
+  return element ? element.tagName.toLowerCase() : null;
+} // the reason mentioned above is the same reason we're not using buildQueries
+
+
+const getMultipleError = (c, text) => `Found multiple elements with the text of: ${text}`;
+
+const queryByLabelText = (0, _allUtils.wrapSingleQueryWithSuggestion)((0, _allUtils.makeSingleQuery)(queryAllByLabelText, getMultipleError), queryAllByLabelText.name, 'query');
+exports.queryByLabelText = queryByLabelText;
+const getByLabelText = (0, _allUtils.makeSingleQuery)(getAllByLabelText, getMultipleError);
+const findAllByLabelText = (0, _allUtils.makeFindQuery)((0, _allUtils.wrapAllByQueryWithSuggestion)(getAllByLabelText, getAllByLabelText.name, 'findAll'));
+exports.findAllByLabelText = findAllByLabelText;
+const findByLabelText = (0, _allUtils.makeFindQuery)((0, _allUtils.wrapSingleQueryWithSuggestion)(getByLabelText, getAllByLabelText.name, 'find'));
+exports.findByLabelText = findByLabelText;
+const getAllByLabelTextWithSuggestions = (0, _allUtils.wrapAllByQueryWithSuggestion)(getAllByLabelText, getAllByLabelText.name, 'getAll');
+exports.getAllByLabelText = getAllByLabelTextWithSuggestions;
+const getByLabelTextWithSuggestions = (0, _allUtils.wrapSingleQueryWithSuggestion)(getByLabelText, getAllByLabelText.name, 'get');
+exports.getByLabelText = getByLabelTextWithSuggestions;
+const queryAllByLabelTextWithSuggestions = (0, _allUtils.wrapAllByQueryWithSuggestion)(queryAllByLabelText, queryAllByLabelText.name, 'queryAll');
+exports.queryAllByLabelText = queryAllByLabelTextWithSuggestions;

web/node_modules/@testing-library/dom/dist/queries/placeholder-text.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findByPlaceholderText = exports.findAllByPlaceholderText = exports.getAllByPlaceholderText = exports.getByPlaceholderText = exports.queryAllByPlaceholderText = exports.queryByPlaceholderText = void 0;
+
+var _queryHelpers = require("../query-helpers");
+
+var _helpers = require("../helpers");
+
+var _allUtils = require("./all-utils");
+
+const queryAllByPlaceholderText = (...args) => {
+  (0, _helpers.checkContainerType)(args[0]); // TODO: Remove ignore after `queryAllByAttribute` will be moved to TS
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+
+  return (0, _allUtils.queryAllByAttribute)('placeholder', ...args);
+};
+
+const getMultipleError = (c, text) => `Found multiple elements with the placeholder text of: ${text}`;
+
+const getMissingError = (c, text) => `Unable to find an element with the placeholder text of: ${text}`;
+
+const queryAllByPlaceholderTextWithSuggestions = (0, _queryHelpers.wrapAllByQueryWithSuggestion)(queryAllByPlaceholderText, queryAllByPlaceholderText.name, 'queryAll');
+exports.queryAllByPlaceholderText = queryAllByPlaceholderTextWithSuggestions;
+const [queryByPlaceholderText, getAllByPlaceholderText, getByPlaceholderText, findAllByPlaceholderText, findByPlaceholderText] = (0, _allUtils.buildQueries)(queryAllByPlaceholderText, getMultipleError, getMissingError);
+exports.findByPlaceholderText = findByPlaceholderText;
+exports.findAllByPlaceholderText = findAllByPlaceholderText;
+exports.getByPlaceholderText = getByPlaceholderText;
+exports.getAllByPlaceholderText = getAllByPlaceholderText;
+exports.queryByPlaceholderText = queryByPlaceholderText;

web/node_modules/@testing-library/dom/dist/queries/role.js

@@ -0,0 +1,226 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findByRole = exports.findAllByRole = exports.getByRole = exports.getAllByRole = exports.queryAllByRole = exports.queryByRole = void 0;
+
+var _domAccessibilityApi = require("dom-accessibility-api");
+
+var _ariaQuery = require("aria-query");
+
+var _roleHelpers = require("../role-helpers");
+
+var _queryHelpers = require("../query-helpers");
+
+var _helpers = require("../helpers");
+
+var _allUtils = require("./all-utils");
+
+function queryAllByRole(container, role, {
+  exact = true,
+  collapseWhitespace,
+  hidden = (0, _allUtils.getConfig)().defaultHidden,
+  name,
+  trim,
+  normalizer,
+  queryFallbacks = false,
+  selected,
+  checked,
+  pressed,
+  level,
+  expanded
+} = {}) {
+  (0, _helpers.checkContainerType)(container);
+  const matcher = exact ? _allUtils.matches : _allUtils.fuzzyMatches;
+  const matchNormalizer = (0, _allUtils.makeNormalizer)({
+    collapseWhitespace,
+    trim,
+    normalizer
+  });
+
+  if (selected !== undefined) {
+    var _allRoles$get;
+
+    // guard against unknown roles
+    if (((_allRoles$get = _ariaQuery.roles.get(role)) == null ? void 0 : _allRoles$get.props['aria-selected']) === undefined) {
+      throw new Error(`"aria-selected" is not supported on role "${role}".`);
+    }
+  }
+
+  if (checked !== undefined) {
+    var _allRoles$get2;
+
+    // guard against unknown roles
+    if (((_allRoles$get2 = _ariaQuery.roles.get(role)) == null ? void 0 : _allRoles$get2.props['aria-checked']) === undefined) {
+      throw new Error(`"aria-checked" is not supported on role "${role}".`);
+    }
+  }
+
+  if (pressed !== undefined) {
+    var _allRoles$get3;
+
+    // guard against unknown roles
+    if (((_allRoles$get3 = _ariaQuery.roles.get(role)) == null ? void 0 : _allRoles$get3.props['aria-pressed']) === undefined) {
+      throw new Error(`"aria-pressed" is not supported on role "${role}".`);
+    }
+  }
+
+  if (level !== undefined) {
+    // guard against using `level` option with any role other than `heading`
+    if (role !== 'heading') {
+      throw new Error(`Role "${role}" cannot have "level" property.`);
+    }
+  }
+
+  if (expanded !== undefined) {
+    var _allRoles$get4;
+
+    // guard against unknown roles
+    if (((_allRoles$get4 = _ariaQuery.roles.get(role)) == null ? void 0 : _allRoles$get4.props['aria-expanded']) === undefined) {
+      throw new Error(`"aria-expanded" is not supported on role "${role}".`);
+    }
+  }
+
+  const subtreeIsInaccessibleCache = new WeakMap();
+
+  function cachedIsSubtreeInaccessible(element) {
+    if (!subtreeIsInaccessibleCache.has(element)) {
+      subtreeIsInaccessibleCache.set(element, (0, _roleHelpers.isSubtreeInaccessible)(element));
+    }
+
+    return subtreeIsInaccessibleCache.get(element);
+  }
+
+  return Array.from(container.querySelectorAll('*')).filter(node => {
+    const isRoleSpecifiedExplicitly = node.hasAttribute('role');
+
+    if (isRoleSpecifiedExplicitly) {
+      const roleValue = node.getAttribute('role');
+
+      if (queryFallbacks) {
+        return roleValue.split(' ').filter(Boolean).some(text => matcher(text, node, role, matchNormalizer));
+      } // if a custom normalizer is passed then let normalizer handle the role value
+
+
+      if (normalizer) {
+        return matcher(roleValue, node, role, matchNormalizer);
+      } // other wise only send the first word to match
+
+
+      const [firstWord] = roleValue.split(' ');
+      return matcher(firstWord, node, role, matchNormalizer);
+    }
+
+    const implicitRoles = (0, _roleHelpers.getImplicitAriaRoles)(node);
+    return implicitRoles.some(implicitRole => matcher(implicitRole, node, role, matchNormalizer));
+  }).filter(element => {
+    if (selected !== undefined) {
+      return selected === (0, _roleHelpers.computeAriaSelected)(element);
+    }
+
+    if (checked !== undefined) {
+      return checked === (0, _roleHelpers.computeAriaChecked)(element);
+    }
+
+    if (pressed !== undefined) {
+      return pressed === (0, _roleHelpers.computeAriaPressed)(element);
+    }
+
+    if (expanded !== undefined) {
+      return expanded === (0, _roleHelpers.computeAriaExpanded)(element);
+    }
+
+    if (level !== undefined) {
+      return level === (0, _roleHelpers.computeHeadingLevel)(element);
+    } // don't care if aria attributes are unspecified
+
+
+    return true;
+  }).filter(element => {
+    return hidden === false ? (0, _roleHelpers.isInaccessible)(element, {
+      isSubtreeInaccessible: cachedIsSubtreeInaccessible
+    }) === false : true;
+  }).filter(element => {
+    if (name === undefined) {
+      // Don't care
+      return true;
+    }
+
+    return (0, _allUtils.matches)((0, _domAccessibilityApi.computeAccessibleName)(element, {
+      computedStyleSupportsPseudoElements: (0, _allUtils.getConfig)().computedStyleSupportsPseudoElements
+    }), element, name, text => text);
+  });
+}
+
+const getMultipleError = (c, role, {
+  name
+} = {}) => {
+  let nameHint = '';
+
+  if (name === undefined) {
+    nameHint = '';
+  } else if (typeof name === 'string') {
+    nameHint = ` and name "${name}"`;
+  } else {
+    nameHint = ` and name \`${name}\``;
+  }
+
+  return `Found multiple elements with the role "${role}"${nameHint}`;
+};
+
+const getMissingError = (container, role, {
+  hidden = (0, _allUtils.getConfig)().defaultHidden,
+  name
+} = {}) => {
+  if ((0, _allUtils.getConfig)()._disableExpensiveErrorDiagnostics) {
+    return `Unable to find role="${role}"`;
+  }
+
+  let roles = '';
+  Array.from(container.children).forEach(childElement => {
+    roles += (0, _roleHelpers.prettyRoles)(childElement, {
+      hidden,
+      includeName: name !== undefined
+    });
+  });
+  let roleMessage;
+
+  if (roles.length === 0) {
+    if (hidden === false) {
+      roleMessage = 'There are no accessible roles. But there might be some inaccessible roles. ' + 'If you wish to access them, then set the `hidden` option to `true`. ' + 'Learn more about this here: https://testing-library.com/docs/dom-testing-library/api-queries#byrole';
+    } else {
+      roleMessage = 'There are no available roles.';
+    }
+  } else {
+    roleMessage = `
+Here are the ${hidden === false ? 'accessible' : 'available'} roles:
+
+  ${roles.replace(/\n/g, '\n  ').replace(/\n\s\s\n/g, '\n\n')}
+`.trim();
+  }
+
+  let nameHint = '';
+
+  if (name === undefined) {
+    nameHint = '';
+  } else if (typeof name === 'string') {
+    nameHint = ` and name "${name}"`;
+  } else {
+    nameHint = ` and name \`${name}\``;
+  }
+
+  return `
+Unable to find an ${hidden === false ? 'accessible ' : ''}element with the role "${role}"${nameHint}
+
+${roleMessage}`.trim();
+};
+
+const queryAllByRoleWithSuggestions = (0, _queryHelpers.wrapAllByQueryWithSuggestion)(queryAllByRole, queryAllByRole.name, 'queryAll');
+exports.queryAllByRole = queryAllByRoleWithSuggestions;
+const [queryByRole, getAllByRole, getByRole, findAllByRole, findByRole] = (0, _allUtils.buildQueries)(queryAllByRole, getMultipleError, getMissingError);
+exports.findByRole = findByRole;
+exports.findAllByRole = findAllByRole;
+exports.getByRole = getByRole;
+exports.getAllByRole = getAllByRole;
+exports.queryByRole = queryByRole;

web/node_modules/@testing-library/dom/dist/queries/test-id.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findByTestId = exports.findAllByTestId = exports.getAllByTestId = exports.getByTestId = exports.queryAllByTestId = exports.queryByTestId = void 0;
+
+var _helpers = require("../helpers");
+
+var _queryHelpers = require("../query-helpers");
+
+var _allUtils = require("./all-utils");
+
+const getTestIdAttribute = () => (0, _allUtils.getConfig)().testIdAttribute;
+
+const queryAllByTestId = (...args) => {
+  (0, _helpers.checkContainerType)(args[0]); // TODO: Remove ignore after `queryAllByAttribute` will be moved to TS
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+
+  return (0, _allUtils.queryAllByAttribute)(getTestIdAttribute(), ...args);
+};
+
+const getMultipleError = (c, id) => `Found multiple elements by: [${getTestIdAttribute()}="${id}"]`;
+
+const getMissingError = (c, id) => `Unable to find an element by: [${getTestIdAttribute()}="${id}"]`;
+
+const queryAllByTestIdWithSuggestions = (0, _queryHelpers.wrapAllByQueryWithSuggestion)(queryAllByTestId, queryAllByTestId.name, 'queryAll');
+exports.queryAllByTestId = queryAllByTestIdWithSuggestions;
+const [queryByTestId, getAllByTestId, getByTestId, findAllByTestId, findByTestId] = (0, _allUtils.buildQueries)(queryAllByTestId, getMultipleError, getMissingError);
+exports.findByTestId = findByTestId;
+exports.findAllByTestId = findAllByTestId;
+exports.getByTestId = getByTestId;
+exports.getAllByTestId = getAllByTestId;
+exports.queryByTestId = queryByTestId;

web/node_modules/@testing-library/dom/dist/queries/text.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findByText = exports.findAllByText = exports.getAllByText = exports.getByText = exports.queryAllByText = exports.queryByText = void 0;
+
+var _queryHelpers = require("../query-helpers");
+
+var _helpers = require("../helpers");
+
+var _shared = require("../shared");
+
+var _allUtils = require("./all-utils");
+
+const queryAllByText = (container, text, {
+  selector = '*',
+  exact = true,
+  collapseWhitespace,
+  trim,
+  ignore = _shared.DEFAULT_IGNORE_TAGS,
+  normalizer
+} = {}) => {
+  (0, _helpers.checkContainerType)(container);
+  const matcher = exact ? _allUtils.matches : _allUtils.fuzzyMatches;
+  const matchNormalizer = (0, _allUtils.makeNormalizer)({
+    collapseWhitespace,
+    trim,
+    normalizer
+  });
+  let baseArray = [];
+
+  if (typeof container.matches === 'function' && container.matches(selector)) {
+    baseArray = [container];
+  }
+
+  return [...baseArray, ...Array.from(container.querySelectorAll(selector))] // TODO: `matches` according lib.dom.d.ts can get only `string` but according our code it can handle also boolean :)
+  .filter(node => !ignore || !node.matches(ignore)).filter(node => matcher((0, _allUtils.getNodeText)(node), node, text, matchNormalizer));
+};
+
+const getMultipleError = (c, text) => `Found multiple elements with the text: ${text}`;
+
+const getMissingError = (c, text) => `Unable to find an element with the text: ${text}. This could be because the text is broken up by multiple elements. In this case, you can provide a function for your text matcher to make your matcher more flexible.`;
+
+const queryAllByTextWithSuggestions = (0, _queryHelpers.wrapAllByQueryWithSuggestion)(queryAllByText, queryAllByText.name, 'queryAll');
+exports.queryAllByText = queryAllByTextWithSuggestions;
+const [queryByText, getAllByText, getByText, findAllByText, findByText] = (0, _allUtils.buildQueries)(queryAllByText, getMultipleError, getMissingError);
+exports.findByText = findByText;
+exports.findAllByText = findAllByText;
+exports.getByText = getByText;
+exports.getAllByText = getAllByText;
+exports.queryByText = queryByText;

web/node_modules/@testing-library/dom/dist/queries/title.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findByTitle = exports.findAllByTitle = exports.getAllByTitle = exports.getByTitle = exports.queryAllByTitle = exports.queryByTitle = void 0;
+
+var _queryHelpers = require("../query-helpers");
+
+var _helpers = require("../helpers");
+
+var _allUtils = require("./all-utils");
+
+const isSvgTitle = node => {
+  var _node$parentElement;
+
+  return node.tagName.toLowerCase() === 'title' && ((_node$parentElement = node.parentElement) == null ? void 0 : _node$parentElement.tagName.toLowerCase()) === 'svg';
+};
+
+const queryAllByTitle = (container, text, {
+  exact = true,
+  collapseWhitespace,
+  trim,
+  normalizer
+} = {}) => {
+  (0, _helpers.checkContainerType)(container);
+  const matcher = exact ? _allUtils.matches : _allUtils.fuzzyMatches;
+  const matchNormalizer = (0, _allUtils.makeNormalizer)({
+    collapseWhitespace,
+    trim,
+    normalizer
+  });
+  return Array.from(container.querySelectorAll('[title], svg > title')).filter(node => matcher(node.getAttribute('title'), node, text, matchNormalizer) || isSvgTitle(node) && matcher((0, _allUtils.getNodeText)(node), node, text, matchNormalizer));
+};
+
+const getMultipleError = (c, title) => `Found multiple elements with the title: ${title}.`;
+
+const getMissingError = (c, title) => `Unable to find an element with the title: ${title}.`;
+
+const queryAllByTitleWithSuggestions = (0, _queryHelpers.wrapAllByQueryWithSuggestion)(queryAllByTitle, queryAllByTitle.name, 'queryAll');
+exports.queryAllByTitle = queryAllByTitleWithSuggestions;
+const [queryByTitle, getAllByTitle, getByTitle, findAllByTitle, findByTitle] = (0, _allUtils.buildQueries)(queryAllByTitle, getMultipleError, getMissingError);
+exports.findByTitle = findByTitle;
+exports.findAllByTitle = findAllByTitle;
+exports.getByTitle = getByTitle;
+exports.getAllByTitle = getAllByTitle;
+exports.queryByTitle = queryByTitle;