wix-style-react/dist/src/RadioGroup/RadioGroup.uni.driver.js

wix-style-react

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.radioGroupUniDriverFactory = void 0;

var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));

var _baseDriver = require("wix-ui-test-utils/base-driver");

var _RadioUni = require("../Radio/Radio.uni.driver");

var _constants = require("./constants");

var _constants2 = require("../Radio/constants");

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var radioGroupUniDriverFactory = function radioGroupUniDriverFactory(base, body) {
  var getOptionContainer = function getOptionContainer() {
    return base.$("[data-hook=\"".concat(_constants.dataHooks.RadioOptionContainer, "\"]"));
  };

  var getRadios = /*#__PURE__*/function () {
    var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
      return _regenerator["default"].wrap(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              _context.next = 2;
              return base.$$("[data-hook^=\"".concat(_constants.dataHooks.RadioContainer, "-\"] > :first-child")).map(function (radio) {
                return radioButtonUniDriverFactory(radio, body, getOptionContainer);
              });

            case 2:
              return _context.abrupt("return", _context.sent);

            case 3:
            case "end":
              return _context.stop();
          }
        }
      }, _callee);
    }));

    return function getRadios() {
      return _ref.apply(this, arguments);
    };
  }();

  var getRadioByValue = /*#__PURE__*/function () {
    var _ref2 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(value) {
      return _regenerator["default"].wrap(function _callee2$(_context2) {
        while (1) {
          switch (_context2.prev = _context2.next) {
            case 0:
              return _context2.abrupt("return", radioButtonUniDriverFactory(base.$("[data-hook=\"".concat(_constants.dataHooks.RadioContainer, "-").concat(value, "\"] > :first-child")), body, getOptionContainer));

            case 1:
            case "end":
              return _context2.stop();
          }
        }
      }, _callee2);
    }));

    return function getRadioByValue(_x) {
      return _ref2.apply(this, arguments);
    };
  }();

  var getRadioByIndex = /*#__PURE__*/function () {
    var _ref3 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(index) {
      return _regenerator["default"].wrap(function _callee3$(_context3) {
        while (1) {
          switch (_context3.prev = _context3.next) {
            case 0:
              _context3.next = 2;
              return getRadios();

            case 2:
              _context3.t0 = index;
              return _context3.abrupt("return", _context3.sent[_context3.t0]);

            case 4:
            case "end":
              return _context3.stop();
          }
        }
      }, _callee3);
    }));

    return function getRadioByIndex(_x2) {
      return _ref3.apply(this, arguments);
    };
  }();

  var getSelectedRadio = /*#__PURE__*/function () {
    var _ref4 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4() {
      var _iterator, _step, radio;

      return _regenerator["default"].wrap(function _callee4$(_context4) {
        while (1) {
          switch (_context4.prev = _context4.next) {
            case 0:
              _context4.t0 = _createForOfIteratorHelper;
              _context4.next = 3;
              return getRadios();

            case 3:
              _context4.t1 = _context4.sent;
              _iterator = (0, _context4.t0)(_context4.t1);
              _context4.prev = 5;

              _iterator.s();

            case 7:
              if ((_step = _iterator.n()).done) {
                _context4.next = 15;
                break;
              }

              radio = _step.value;
              _context4.next = 11;
              return radio.isChecked();

            case 11:
              if (!_context4.sent) {
                _context4.next = 13;
                break;
              }

              return _context4.abrupt("return", radio);

            case 13:
              _context4.next = 7;
              break;

            case 15:
              _context4.next = 20;
              break;

            case 17:
              _context4.prev = 17;
              _context4.t2 = _context4["catch"](5);

              _iterator.e(_context4.t2);

            case 20:
              _context4.prev = 20;

              _iterator.f();

              return _context4.finish(20);

            case 23:
            case "end":
              return _context4.stop();
          }
        }
      }, _callee4, null, [[5, 17, 20, 23]]);
    }));

    return function getSelectedRadio() {
      return _ref4.apply(this, arguments);
    };
  }();

  return _objectSpread(_objectSpread({}, (0, _baseDriver.baseUniDriverFactory)(base, body)), {}, {
    /** Selects the radio that matches the provided value */
    selectByValue: function () {
      var _selectByValue = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee5(value) {
        return _regenerator["default"].wrap(function _callee5$(_context5) {
          while (1) {
            switch (_context5.prev = _context5.next) {
              case 0:
                _context5.next = 2;
                return getRadioByValue(value);

              case 2:
                return _context5.abrupt("return", _context5.sent.click());

              case 3:
              case "end":
                return _context5.stop();
            }
          }
        }, _callee5);
      }));

      function selectByValue(_x3) {
        return _selectByValue.apply(this, arguments);
      }

      return selectByValue;
    }(),

    /** Selects the radio in the provided index */
    selectByIndex: function () {
      var _selectByIndex = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee6(index) {
        return _regenerator["default"].wrap(function _callee6$(_context6) {
          while (1) {
            switch (_context6.prev = _context6.next) {
              case 0:
                _context6.next = 2;
                return getRadioByIndex(index);

              case 2:
                return _context6.abrupt("return", _context6.sent.click());

              case 3:
              case "end":
                return _context6.stop();
            }
          }
        }, _callee6);
      }));

      function selectByIndex(_x4) {
        return _selectByIndex.apply(this, arguments);
      }

      return selectByIndex;
    }(),

    /** Get the radio value in the provided index */
    getRadioValueAt: function () {
      var _getRadioValueAt = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee7(index) {
        return _regenerator["default"].wrap(function _callee7$(_context7) {
          while (1) {
            switch (_context7.prev = _context7.next) {
              case 0:
                _context7.next = 2;
                return getRadioByIndex(index);

              case 2:
                return _context7.abrupt("return", _context7.sent.getValue());

              case 3:
              case "end":
                return _context7.stop();
            }
          }
        }, _callee7);
      }));

      function getRadioValueAt(_x5) {
        return _getRadioValueAt.apply(this, arguments);
      }

      return getRadioValueAt;
    }(),

    /** Get the radio element in the provided index, returns an element merged with the RadioButton driver methods */
    getRadioAtIndex: function () {
      var _getRadioAtIndex = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee8(index) {
        return _regenerator["default"].wrap(function _callee8$(_context8) {
          while (1) {
            switch (_context8.prev = _context8.next) {
              case 0:
                _context8.next = 2;
                return getRadioByIndex(index);

              case 2:
                return _context8.abrupt("return", _context8.sent);

              case 3:
              case "end":
                return _context8.stop();
            }
          }
        }, _callee8);
      }));

      function getRadioAtIndex(_x6) {
        return _getRadioAtIndex.apply(this, arguments);
      }

      return getRadioAtIndex;
    }(),

    /** Get the value of the selected radio */
    getSelectedValue: function () {
      var _getSelectedValue = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee9() {
        var selected;
        return _regenerator["default"].wrap(function _callee9$(_context9) {
          while (1) {
            switch (_context9.prev = _context9.next) {
              case 0:
                _context9.next = 2;
                return getSelectedRadio();

              case 2:
                selected = _context9.sent;
                return _context9.abrupt("return", selected ? selected.getValue() : null);

              case 4:
              case "end":
                return _context9.stop();
            }
          }
        }, _callee9);
      }));

      function getSelectedValue() {
        return _getSelectedValue.apply(this, arguments);
      }

      return getSelectedValue;
    }(),

    /** Checks if the radio in the provided index is disabled */
    isRadioDisabled: function () {
      var _isRadioDisabled = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee10(index) {
        return _regenerator["default"].wrap(function _callee10$(_context10) {
          while (1) {
            switch (_context10.prev = _context10.next) {
              case 0:
                _context10.next = 2;
                return getRadioByIndex(index);

              case 2:
                return _context10.abrupt("return", _context10.sent.isDisabled());

              case 3:
              case "end":
                return _context10.stop();
            }
          }
        }, _callee10);
      }));

      function isRadioDisabled(_x7) {
        return _isRadioDisabled.apply(this, arguments);
      }

      return isRadioDisabled;
    }(),

    /** Get the number of rendered radios */
    getNumberOfRadios: function () {
      var _getNumberOfRadios = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee11() {
        return _regenerator["default"].wrap(function _callee11$(_context11) {
          while (1) {
            switch (_context11.prev = _context11.next) {
              case 0:
                _context11.next = 2;
                return getRadios();

              case 2:
                return _context11.abrupt("return", _context11.sent.length);

              case 3:
              case "end":
                return _context11.stop();
            }
          }
        }, _callee11);
      }));

      function getNumberOfRadios() {
        return _getNumberOfRadios.apply(this, arguments);
      }

      return getNumberOfRadios;
    }(),

    /** Get the value of radio button id at the provided index */
    getRadioIdAt: function () {
      var _getRadioIdAt = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee12(index) {
        return _regenerator["default"].wrap(function _callee12$(_context12) {
          while (1) {
            switch (_context12.prev = _context12.next) {
              case 0:
                _context12.next = 2;
                return getRadioByIndex(index);

              case 2:
                return _context12.abrupt("return", _context12.sent.getId());

              case 3:
              case "end":
                return _context12.stop();
            }
          }
        }, _callee12);
      }));

      function getRadioIdAt(_x8) {
        return _getRadioIdAt.apply(this, arguments);
      }

      return getRadioIdAt;
    }(),

    /** Get the value of radio button name at the provided index */
    getRadioName: function () {
      var _getRadioName = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee13() {
        return _regenerator["default"].wrap(function _callee13$(_context13) {
          while (1) {
            switch (_context13.prev = _context13.next) {
              case 0:
                _context13.next = 2;
                return getRadioByIndex(0);

              case 2:
                return _context13.abrupt("return", _context13.sent.getName());

              case 3:
              case "end":
                return _context13.stop();
            }
          }
        }, _callee13);
      }));

      function getRadioName() {
        return _getRadioName.apply(this, arguments);
      }

      return getRadioName;
    }(),

    /** Checks if the radio with the provided index is checked */
    isRadioChecked: function () {
      var _isRadioChecked = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee14(index) {
        return _regenerator["default"].wrap(function _callee14$(_context14) {
          while (1) {
            switch (_context14.prev = _context14.next) {
              case 0:
                _context14.next = 2;
                return getRadioByIndex(index);

              case 2:
                return _context14.abrupt("return", _context14.sent.isChecked());

              case 3:
              case "end":
                return _context14.stop();
            }
          }
        }, _callee14);
      }));

      function isRadioChecked(_x9) {
        return _isRadioChecked.apply(this, arguments);
      }

      return isRadioChecked;
    }()
  });
};

exports.radioGroupUniDriverFactory = radioGroupUniDriverFactory;

var radioButtonUniDriverFactory = function radioButtonUniDriverFactory(base, body, container) {
  var getByDataHook = function getByDataHook(dataHook) {
    return base.$("[data-hook=\"".concat(dataHook, "\"]"));
  };

  var radioLabel = function radioLabel() {
    return getByDataHook(_constants2.dataHooks.label);
  };

  return _objectSpread(_objectSpread({}, (0, _RadioUni.radioUniDriverFactory)(base, body)), {}, {
    /** Simulating a check action by clicking the input element */
    check: function check() {
      return base.click();
    },

    /** Getting the component's label text value */
    getLabel: function getLabel() {
      return radioLabel().text();
    },

    /** Getting the component's label element */
    // eslint-disable-next-line no-restricted-properties
    getLabelElement: function getLabelElement() {
      return radioLabel().getNative();
    },

    /** Getting the component's tab-index value */
    // This method is deprecated and this solution is in order not to break users
    getTabIndex: function getTabIndex() {
      return '1';
    },

    /** Getting the component's content element */
    getContent: function getContent() {
      return (// eslint-disable-next-line no-restricted-properties
        container().$("[data-hook=\"".concat(_constants.dataHooks.RadioContent, "\"]")).getNative()
      );
    }
  });
};